@codingame/monaco-vscode-workbench-service-override 3.2.2 → 4.0.0

package/override/vs/platform/dialogs/common/dialogs.js

@@ -1,3 +1,5 @@
+export { AbstractDialogHandler, IDialogService, IFileDialogService, getFileNamesMessage } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
 var ConfirmResult;
 ( (function(ConfirmResult) {
     ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-workbench-service-override",
-  "version": "3.2.2",
+  "version": "4.0.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,18 +18,19 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@3.2.2",
-    "@codingame/monaco-vscode-keybindings-service-override": "3.2.2",
-    "@codingame/monaco-vscode-quickaccess-service-override": "3.2.2",
-    "@codingame/monaco-vscode-bulk-edit-service-override": "3.2.2",
-    "@codingame/monaco-vscode-view-title-bar-service-override": "3.2.2",
-    "@codingame/monaco-vscode-view-status-bar-service-override": "3.2.2",
-    "@codingame/monaco-vscode-view-banner-service-override": "3.2.2",
-    "@codingame/monaco-vscode-files-service-override": "3.2.2",
-    "@codingame/monaco-vscode-extensions-service-override": "3.2.2",
-    "@codingame/monaco-vscode-environment-service-override": "3.2.2",
-    "@codingame/monaco-vscode-layout-service-override": "3.2.2",
-    "@codingame/monaco-vscode-host-service-override": "3.2.2",
-    "@codingame/monaco-vscode-base-service-override": "3.2.2"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.0.0",
+    "@codingame/monaco-vscode-views-service-override": "4.0.0",
+    "@codingame/monaco-vscode-keybindings-service-override": "4.0.0",
+    "@codingame/monaco-vscode-quickaccess-service-override": "4.0.0",
+    "@codingame/monaco-vscode-bulk-edit-service-override": "4.0.0",
+    "@codingame/monaco-vscode-view-title-bar-service-override": "4.0.0",
+    "@codingame/monaco-vscode-view-status-bar-service-override": "4.0.0",
+    "@codingame/monaco-vscode-view-banner-service-override": "4.0.0",
+    "@codingame/monaco-vscode-files-service-override": "4.0.0",
+    "@codingame/monaco-vscode-extensions-service-override": "4.0.0",
+    "@codingame/monaco-vscode-environment-service-override": "4.0.0",
+    "@codingame/monaco-vscode-layout-service-override": "4.0.0",
+    "@codingame/monaco-vscode-host-service-override": "4.0.0",
+    "@codingame/monaco-vscode-base-service-override": "4.0.0"
   }
 }

package/tools/editor.js

@@ -0,0 +1,588 @@
+import { __decorate, __param } from '../external/tslib/tslib.es6.js';
+import { StandaloneServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
+import { isPreferredGroup, SIDE_GROUP } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { EditorCloseContext, isEditorInput, isResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor';
+import { applyTextEditorOptions } from 'vscode/vscode/vs/workbench/common/editor/editorOptions';
+import { DEFAULT_EDITOR_MIN_DIMENSIONS, DEFAULT_EDITOR_MAX_DIMENSIONS } from 'vscode/vscode/vs/workbench/browser/parts/editor/editor';
+import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
+import { StandaloneCodeEditor, StandaloneEditor } from 'vscode/vscode/vs/editor/standalone/browser/standaloneCodeEditor';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { EditorService } from 'vscode/vscode/vs/workbench/services/editor/browser/editorService';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IWorkspaceTrustRequestService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust';
+import { IEditorResolverService } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { ITextEditorService } from 'vscode/vscode/vs/workbench/services/textfile/common/textEditorService';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
+import { TextResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor/textResourceEditorInput';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
+import { unsupported } from '../tools.js';
+
+var StandaloneEditorGroup_1;
+class EmptyEditorGroup {
+    constructor() {
+        this.isTransient = () => false;
+        this.windowId = mainWindow.vscodeWindowId;
+        this.createEditorActions = unsupported;
+        this.onDidFocus = Event.None;
+        this.onDidOpenEditorFail = Event.None;
+        this.whenRestored = Promise.resolve();
+        this.disposed = false;
+        this.setActive = unsupported;
+        this.notifyIndexChanged = unsupported;
+        this.relayout = unsupported;
+        this.dispose = unsupported;
+        this.toJSON = unsupported;
+        this.minimumWidth = 0;
+        this.maximumWidth = Number.POSITIVE_INFINITY;
+        this.minimumHeight = 0;
+        this.maximumHeight = Number.POSITIVE_INFINITY;
+        this.onDidChange = Event.None;
+        this.layout = unsupported;
+        this.onDidModelChange = Event.None;
+        this.onWillDispose = Event.None;
+        this.onDidActiveEditorChange = Event.None;
+        this.onWillCloseEditor = Event.None;
+        this.onDidCloseEditor = Event.None;
+        this.onWillMoveEditor = Event.None;
+        this.onWillOpenEditor = Event.None;
+        this.id = 0;
+        this.index = 0;
+        this.label = 'main';
+        this.ariaLabel = 'main';
+        this.activeEditorPane = undefined;
+        this.activeEditor = null;
+        this.previewEditor = null;
+        this.count = 0;
+        this.isEmpty = false;
+        this.isLocked = false;
+        this.stickyCount = 0;
+        this.editors = [];
+        this.getEditors = () => [];
+        this.findEditors = () => [];
+        this.getEditorByIndex = () => undefined;
+        this.getIndexOfEditor = unsupported;
+        this.openEditor = unsupported;
+        this.openEditors = unsupported;
+        this.isPinned = () => false;
+        this.isSticky = () => false;
+        this.isActive = () => false;
+        this.contains = () => false;
+        this.moveEditor = unsupported;
+        this.moveEditors = unsupported;
+        this.copyEditor = unsupported;
+        this.copyEditors = unsupported;
+        this.closeEditor = unsupported;
+        this.closeEditors = unsupported;
+        this.closeAllEditors = unsupported;
+        this.replaceEditors = unsupported;
+        this.pinEditor = () => { };
+        this.stickEditor = () => { };
+        this.unstickEditor = () => { };
+        this.lock = () => { };
+        this.isFirst = unsupported;
+        this.isLast = unsupported;
+    }
+    get groupsView() {
+        return unsupported();
+    }
+    notifyLabelChanged() { }
+    get titleHeight() {
+        return unsupported();
+    }
+    get element() {
+        return unsupported();
+    }
+    get scopedContextKeyService() { return StandaloneServices.get(IContextKeyService); }
+    focus() {
+    }
+}
+const fakeActiveGroup = new EmptyEditorGroup();
+class SimpleEditorPane {
+    constructor(editor) {
+        this.editor = editor;
+        this.onDidChangeControl = Event.None;
+        this.onDidChangeSizeConstraints = Event.None;
+        this.onDidFocus = Event.None;
+        this.onDidBlur = Event.None;
+        this.input = undefined;
+        this.options = undefined;
+        this.group = fakeActiveGroup;
+        this.scopedContextKeyService = undefined;
+        this.getViewState = unsupported;
+        this.isVisible = unsupported;
+        this.hasFocus = unsupported;
+        this.getId = unsupported;
+        this.getTitle = unsupported;
+        this.focus = unsupported;
+    }
+    get minimumWidth() { return DEFAULT_EDITOR_MIN_DIMENSIONS.width; }
+    get maximumWidth() { return DEFAULT_EDITOR_MAX_DIMENSIONS.width; }
+    get minimumHeight() { return DEFAULT_EDITOR_MIN_DIMENSIONS.height; }
+    get maximumHeight() { return DEFAULT_EDITOR_MAX_DIMENSIONS.height; }
+    getControl() {
+        return this.editor;
+    }
+}
+function wrapOpenEditor(textModelService, defaultBehavior, fallbackBahavior) {
+    async function openEditor(editor, optionsOrPreferredGroup, preferredGroup) {
+        const options = isEditorInput(editor) ? optionsOrPreferredGroup : editor.options;
+        if (isPreferredGroup(optionsOrPreferredGroup)) {
+            preferredGroup = optionsOrPreferredGroup;
+        }
+        const resource = isResourceEditorInput(editor) || isEditorInput(editor) ? editor.resource : undefined;
+        if (resource == null || !textModelService.canHandleResource(resource)) {
+            return defaultBehavior(editor, optionsOrPreferredGroup, preferredGroup);
+        }
+        let modelEditor;
+        const codeEditors = StandaloneServices.get(ICodeEditorService).listCodeEditors();
+        modelEditor = codeEditors.find(editor => editor instanceof StandaloneEditor && editor.getModel() != null && ( editor.getModel().uri.toString()) === ( resource.toString()));
+        if (modelEditor == null) {
+            const defaultBehaviorResult = await defaultBehavior(editor, optionsOrPreferredGroup, preferredGroup);
+            if (defaultBehaviorResult != null) {
+                return defaultBehaviorResult;
+            }
+            const modelRef = await textModelService.createModelReference(resource);
+            modelEditor = await fallbackBahavior?.(modelRef, options, preferredGroup === SIDE_GROUP);
+            if (modelEditor == null) {
+                modelRef.dispose();
+                return undefined;
+            }
+        }
+        if (options != null) {
+            applyTextEditorOptions(options, modelEditor, 1 );
+        }
+        if (!(options?.preserveFocus ?? false)) {
+            modelEditor.focus();
+            modelEditor.getContainerDomNode().scrollIntoView();
+        }
+        return new SimpleEditorPane(modelEditor);
+    }
+    return openEditor;
+}
+let MonacoEditorService = class MonacoEditorService extends EditorService {
+    constructor(_openEditorFallback, _isEditorPartVisible, _editorGroupService, instantiationService, fileService, configurationService, contextService, uriIdentityService, editorResolverService, workspaceTrustRequestService, hostService, textEditorService, textModelService) {
+        super(undefined, _editorGroupService, instantiationService, fileService, configurationService, contextService, uriIdentityService, editorResolverService, workspaceTrustRequestService, hostService, textEditorService);
+        this._isEditorPartVisible = _isEditorPartVisible;
+        this.openEditor = wrapOpenEditor(textModelService, this.openEditor.bind(this), _openEditorFallback);
+    }
+    get activeTextEditorControl() {
+        const focusedCodeEditor = StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor();
+        if (focusedCodeEditor != null && focusedCodeEditor instanceof StandaloneCodeEditor) {
+            return focusedCodeEditor;
+        }
+        return super.activeTextEditorControl;
+    }
+    async openEditor(editor, optionsOrPreferredGroup, preferredGroup) {
+        if (!this._isEditorPartVisible()) {
+            return undefined;
+        }
+        return super.openEditor(editor, optionsOrPreferredGroup, preferredGroup);
+    }
+};
+MonacoEditorService = __decorate([
+    ( __param(2, IEditorGroupsService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IFileService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IWorkspaceContextService)),
+    ( __param(7, IUriIdentityService)),
+    ( __param(8, IEditorResolverService)),
+    ( __param(9, IWorkspaceTrustRequestService)),
+    ( __param(10, IHostService)),
+    ( __param(11, ITextEditorService)),
+    ( __param(12, ITextModelService))
+], MonacoEditorService);
+class StandaloneEditorPane {
+    constructor(editor, input, group) {
+        this.editor = editor;
+        this.input = input;
+        this.group = group;
+        this.onDidChangeControl = Event.None;
+        this.options = undefined;
+        this.minimumWidth = 0;
+        this.maximumWidth = Number.POSITIVE_INFINITY;
+        this.minimumHeight = 0;
+        this.maximumHeight = Number.POSITIVE_INFINITY;
+        this.onDidChangeSizeConstraints = Event.None;
+        this.scopedContextKeyService = undefined;
+        this.onDidFocus = this.editor.onDidFocusEditorWidget;
+        this.onDidBlur = this.editor.onDidBlurEditorWidget;
+    }
+    getControl() {
+        return this.editor;
+    }
+    getViewState() {
+        return undefined;
+    }
+    isVisible() {
+        return true;
+    }
+    hasFocus() {
+        return this.editor.hasWidgetFocus();
+    }
+    getId() {
+        return this.editor.getId();
+    }
+    getTitle() {
+        return undefined;
+    }
+    focus() {
+        this.editor.focus();
+    }
+}
+let StandaloneEditorGroup = StandaloneEditorGroup_1 = class StandaloneEditorGroup extends Disposable {
+    constructor(editor, instantiationService, scopedContextKeyService) {
+        super();
+        this.editor = editor;
+        this.scopedContextKeyService = scopedContextKeyService;
+        this.active = false;
+        this.isTransient = () => false;
+        this.windowId = mainWindow.vscodeWindowId;
+        this.onDidFocus = this.editor.onDidFocusEditorWidget;
+        this.onDidOpenEditorFail = Event.None;
+        this.whenRestored = Promise.resolve();
+        this.disposed = false;
+        this.notifyIndexChanged = unsupported;
+        this.relayout = unsupported;
+        this.toJSON = unsupported;
+        this.minimumWidth = 0;
+        this.maximumWidth = Number.POSITIVE_INFINITY;
+        this.minimumHeight = 0;
+        this.maximumHeight = Number.POSITIVE_INFINITY;
+        this.onDidChange = this.editor.onDidLayoutChange;
+        this.layout = () => this.editor.layout();
+        this._onDidModelChange = new Emitter();
+        this.onDidModelChange = this._onDidModelChange.event;
+        this.onWillDispose = this.editor.onDidDispose;
+        this._onDidActiveEditorChange = new Emitter();
+        this.onDidActiveEditorChange = this._onDidActiveEditorChange.event;
+        this.onWillCloseEditor = Event.None;
+        this._onDidCloseEditor = new Emitter();
+        this.onDidCloseEditor = this._onDidCloseEditor.event;
+        this.onWillMoveEditor = Event.None;
+        this._onWillOpenEditor = new Emitter();
+        this.onWillOpenEditor = this._onWillOpenEditor.event;
+        this.id = --StandaloneEditorGroup_1.idCounter;
+        this.index = -1;
+        this.label = `standalone editor ${-this.id}`;
+        this.ariaLabel = `standalone editor ${-this.id}`;
+        this.previewEditor = null;
+        this.isLocked = true;
+        this.stickyCount = 0;
+        this.getEditors = () => this.editors;
+        this.findEditors = (resource) => this.pane != null && ( resource.toString()) === ( this.pane.input.resource.toString()) ? [this.pane.input] : [];
+        this.getEditorByIndex = (index) => this.pane != null && index === 0 ? this.pane.input : undefined;
+        this.getIndexOfEditor = (editorInput) => this.pane != null && this.pane.input === editorInput ? 0 : -1;
+        this.openEditor = async (editor) => {
+            if (editor.isDisposed()) {
+                return undefined;
+            }
+            if (editor instanceof TextResourceEditorInput && ( editor.resource.toString()) === this.pane?.input.resource.toString()) {
+                this.focus();
+                return this.pane;
+            }
+            return undefined;
+        };
+        this.openEditors = async (editors) => {
+            if (editors.length === 1) {
+                return this.openEditor(editors[0].editor);
+            }
+            return undefined;
+        };
+        this.isPinned = () => false;
+        this.isSticky = () => false;
+        this.isActive = () => this.editor.hasWidgetFocus();
+        this.contains = (candidate) => {
+            return this.pane != null && this.pane.input === candidate;
+        };
+        this.moveEditor = unsupported;
+        this.moveEditors = unsupported;
+        this.copyEditor = unsupported;
+        this.copyEditors = unsupported;
+        this.closeEditor = unsupported;
+        this.closeEditors = unsupported;
+        this.closeAllEditors = unsupported;
+        this.replaceEditors = unsupported;
+        this.pinEditor = () => { };
+        this.stickEditor = () => { };
+        this.unstickEditor = () => { };
+        this.lock = () => { };
+        this.isFirst = unsupported;
+        this.isLast = unsupported;
+        const onNewModel = (uri) => {
+            const editorInput = instantiationService.createInstance(TextResourceEditorInput, uri, undefined, undefined, undefined, undefined);
+            this._onWillOpenEditor.fire({
+                editor: editorInput,
+                groupId: this.id
+            });
+            this.pane = new StandaloneEditorPane(editor, editorInput, this);
+            this._onDidModelChange.fire({
+                kind: 4 ,
+                editor: editorInput,
+                editorIndex: 0
+            });
+            this._onDidActiveEditorChange.fire({
+                editor: editorInput
+            });
+        };
+        const onRemovedModel = (uri) => {
+            if (this.pane != null && ( this.pane.input.resource.toString()) === ( uri.toString())) {
+                const pane = this.pane;
+                this.pane = undefined;
+                this._onDidModelChange.fire({
+                    kind: 5 ,
+                    editorIndex: 0
+                });
+                this._onDidActiveEditorChange.fire({
+                    editor: undefined
+                });
+                this._onDidCloseEditor.fire({
+                    context: EditorCloseContext.UNKNOWN,
+                    editor: pane.input,
+                    groupId: this.id,
+                    index: 0,
+                    sticky: false
+                });
+            }
+        };
+        editor.onDidChangeModel((e) => {
+            if (e.oldModelUrl != null) {
+                onRemovedModel(e.oldModelUrl);
+            }
+            if (e.newModelUrl != null) {
+                onNewModel(e.newModelUrl);
+            }
+        });
+        this._register({
+            dispose: () => {
+                const model = editor.getModel();
+                if (model != null) {
+                    onRemovedModel(model.uri);
+                }
+            }
+        });
+        const currentModel = editor.getModel();
+        if (currentModel != null) {
+            const editorInput = instantiationService.createInstance(TextResourceEditorInput, currentModel.uri, undefined, undefined, undefined, undefined);
+            this.pane = new StandaloneEditorPane(editor, editorInput, this);
+        }
+    }
+    get groupsView() {
+        return unsupported();
+    }
+    notifyLabelChanged() { }
+    createEditorActions() {
+        return {
+            actions: {
+                primary: [],
+                secondary: []
+            },
+            onDidChange: Event.None
+        };
+    }
+    get titleHeight() { return unsupported(); }
+    setActive(isActive) {
+        this.active = isActive;
+    }
+    get element() {
+        return this.editor.getContainerDomNode();
+    }
+    get activeEditorPane() {
+        return this.pane;
+    }
+    get activeEditor() {
+        return this.pane?.input ?? null;
+    }
+    get count() {
+        return this.pane != null ? 1 : 0;
+    }
+    get isEmpty() {
+        return this.pane == null;
+    }
+    get editors() {
+        return this.pane != null ? [this.pane.input] : [];
+    }
+    focus() {
+        this.editor.focus();
+        this.editor.getContainerDomNode().scrollIntoView();
+    }
+};
+StandaloneEditorGroup.idCounter = 0;
+StandaloneEditorGroup = StandaloneEditorGroup_1 = __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IContextKeyService))
+], StandaloneEditorGroup);
+let MonacoDelegateEditorGroupsService = class MonacoDelegateEditorGroupsService extends Disposable {
+    constructor(delegate, instantiationService) {
+        super();
+        this.delegate = delegate;
+        this._serviceBrand = undefined;
+        this.additionalGroups = [];
+        this.activeGroupOverride = undefined;
+        this.onDidCreateAuxiliaryEditorPart = this.delegate.onDidCreateAuxiliaryEditorPart;
+        this.onDidChangeGroupMaximized = this.delegate.onDidChangeGroupMaximized;
+        this._onDidChangeActiveGroup = new Emitter();
+        this.onDidChangeActiveGroup = Event.any(this._onDidChangeActiveGroup.event, this.delegate.onDidChangeActiveGroup);
+        this._onDidAddGroup = new Emitter();
+        this.onDidAddGroup = Event.any(this._onDidAddGroup.event, this.delegate.onDidAddGroup);
+        this._onDidRemoveGroup = new Emitter();
+        this.onDidRemoveGroup = Event.any(this._onDidRemoveGroup.event, this.delegate.onDidRemoveGroup);
+        this.onDidMoveGroup = this.delegate.onDidMoveGroup;
+        this.onDidActivateGroup = this.delegate.onDidActivateGroup;
+        this.onDidChangeGroupIndex = this.delegate.onDidChangeGroupIndex;
+        this.onDidChangeGroupLocked = this.delegate.onDidChangeGroupLocked;
+        this.getLayout = () => {
+            return this.delegate.getLayout();
+        };
+        this.getGroups = (order) => {
+            return [...this.delegate.getGroups(order), ...this.additionalGroups];
+        };
+        this.getGroup = (identifier) => {
+            return this.delegate.getGroup(identifier) ?? this.additionalGroups.find(group => group.id === identifier);
+        };
+        this.activateGroup = (...args) => {
+            return this.delegate.activateGroup(...args);
+        };
+        this.getSize = (...args) => {
+            return this.delegate.getSize(...args);
+        };
+        this.setSize = (...args) => {
+            return this.delegate.setSize(...args);
+        };
+        this.arrangeGroups = (...args) => {
+            return this.delegate.arrangeGroups(...args);
+        };
+        this.applyLayout = (...args) => {
+            return this.delegate.applyLayout(...args);
+        };
+        this.setGroupOrientation = (...args) => {
+            return this.delegate.setGroupOrientation(...args);
+        };
+        this.findGroup = (...args) => {
+            return this.delegate.findGroup(...args);
+        };
+        this.addGroup = (...args) => {
+            return this.delegate.addGroup(...args);
+        };
+        this.removeGroup = (...args) => {
+            return this.delegate.removeGroup(...args);
+        };
+        this.moveGroup = (...args) => {
+            return this.delegate.moveGroup(...args);
+        };
+        this.mergeGroup = (...args) => {
+            return this.delegate.mergeGroup(...args);
+        };
+        this.mergeAllGroups = (...args) => {
+            return this.delegate.mergeAllGroups(...args);
+        };
+        this.copyGroup = (...args) => {
+            return this.delegate.copyGroup(...args);
+        };
+        this.onDidChangeEditorPartOptions = this.delegate.onDidChangeEditorPartOptions;
+        setTimeout(() => {
+            const codeEditorService = StandaloneServices.get(ICodeEditorService);
+            const handleCodeEditor = (editor) => {
+                if (editor instanceof StandaloneEditor) {
+                    let timeout;
+                    const onEditorFocused = () => {
+                        if (timeout != null)
+                            window.clearTimeout(timeout);
+                        this.activeGroupOverride = this.additionalGroups.find(group => group.editor === editor);
+                        this._onDidChangeActiveGroup.fire(this.activeGroup);
+                    };
+                    const onEditorBlurred = () => {
+                        if (timeout != null)
+                            window.clearTimeout(timeout);
+                        timeout = window.setTimeout(() => {
+                            timeout = undefined;
+                            if (this.activeGroupOverride === this.additionalGroups.find(group => group.editor === editor)) {
+                                this.activeGroupOverride = undefined;
+                                this._onDidChangeActiveGroup.fire(this.activeGroup);
+                            }
+                        }, 100);
+                    };
+                    editor.onDidFocusEditorText(onEditorFocused);
+                    editor.onDidFocusEditorWidget(onEditorFocused);
+                    editor.onDidBlurEditorText(onEditorBlurred);
+                    editor.onDidBlurEditorWidget(onEditorBlurred);
+                    if (editor.hasWidgetFocus()) {
+                        onEditorFocused();
+                    }
+                    const newGroup = instantiationService.createInstance(StandaloneEditorGroup, editor);
+                    this.additionalGroups.push(newGroup);
+                    this._onDidAddGroup.fire(newGroup);
+                }
+            };
+            const handleCodeEditorRemoved = (editor) => {
+                if (editor instanceof StandaloneEditor) {
+                    const removedGroup = this.additionalGroups.find(group => group.editor === editor);
+                    if (removedGroup != null) {
+                        removedGroup.dispose();
+                        if (this.activeGroupOverride === removedGroup) {
+                            this.activeGroupOverride = undefined;
+                            this._onDidChangeActiveGroup.fire(this.activeGroup);
+                        }
+                        this.additionalGroups = this.additionalGroups.filter(group => group !== removedGroup);
+                        this._onDidRemoveGroup.fire(removedGroup);
+                    }
+                }
+            };
+            this._register(codeEditorService.onCodeEditorAdd(handleCodeEditor));
+            this._register(codeEditorService.onCodeEditorRemove(handleCodeEditorRemoved));
+            codeEditorService.listCodeEditors().forEach(handleCodeEditor);
+        });
+    }
+    get isReady() {
+        return this.delegate.isReady;
+    }
+    get whenReady() {
+        return this.delegate.whenReady;
+    }
+    get whenRestored() {
+        return this.delegate.whenRestored;
+    }
+    get hasRestorableState() {
+        return this.delegate.hasRestorableState;
+    }
+    get parts() { return this.delegate.parts; }
+    createAuxiliaryEditorPart(options) {
+        return this.delegate.createAuxiliaryEditorPart(options);
+    }
+    get mainPart() { return this.delegate.mainPart; }
+    getPart(container) {
+        return this.delegate.getPart(container);
+    }
+    toggleMaximizeGroup(group) {
+        return this.delegate.toggleMaximizeGroup(group);
+    }
+    toggleExpandGroup(group) {
+        return this.delegate.toggleExpandGroup(group);
+    }
+    createEditorDropTarget(container, delegate) {
+        return this.delegate.createEditorDropTarget(container, delegate);
+    }
+    get groups() {
+        return [...this.additionalGroups, ...this.delegate.groups];
+    }
+    get activeGroup() {
+        return this.activeGroupOverride ?? this.delegate.activeGroup;
+    }
+    get sideGroup() { return this.delegate.sideGroup; }
+    get count() { return this.delegate.count + this.additionalGroups.length; }
+    get orientation() { return this.delegate.orientation; }
+    get partOptions() { return this.delegate.partOptions; }
+};
+MonacoDelegateEditorGroupsService = __decorate([
+    ( __param(1, IInstantiationService))
+], MonacoDelegateEditorGroupsService);
+
+export { MonacoDelegateEditorGroupsService, MonacoEditorService, fakeActiveGroup, wrapOpenEditor };

package/tools/views.d.ts

@@ -19,6 +19,7 @@ export { EditorInput, IEditorCloseHandler } from 'vscode/vscode/vs/workbench/com
 import { IEditorOpenContext, EditorInputCapabilities, Verbosity, IEditorSerializer } from 'vscode/vscode/vs/workbench/common/editor';
 export { EditorInputCapabilities, IEditorSerializer } from 'vscode/vscode/vs/workbench/common/editor';
 import { EditorPane } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorPane';
+import { IEditorGroup } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
 
 type Label = string | {
     short: string;
@@ -64,7 +65,7 @@ declare abstract class SimpleEditorInput extends EditorInput {
     isDirty(): boolean;
     setDirty(dirty: boolean): void;
 }
-declare function registerEditorPane<Services extends BrandedService[]>(typeId: string, name: string, ctor: new (...services: Services) => EditorPane, inputCtors: (new (...args: any[]) => EditorInput)[]): IDisposable;
+declare function registerEditorPane<Services extends BrandedService[]>(typeId: string, name: string, ctor: new (group: IEditorGroup, ...services: Services) => EditorPane, inputCtors: (new (...args: any[]) => EditorInput)[]): IDisposable;
 declare function registerEditor(globPattern: string, editorInfo: RegisteredEditorInfo, editorOptions: RegisteredEditorOptions, factory: EditorInputFactoryObject): IDisposable;
 declare function registerEditorSerializer<Services extends BrandedService[]>(editorTypeId: string, ctor: {
     new (...Services: Services): IEditorSerializer;

package/tools/views.js

@@ -28,14 +28,18 @@ import { DomScrollableElement } from 'vscode/vscode/vs/base/browser/ui/scrollbar
 export { DomScrollableElement } from 'vscode/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
 import { assertIsDefined, assertAllDefined } from 'vscode/vscode/vs/base/common/types';
 export { ConfirmResult } from '../override/vs/platform/dialogs/common/dialogs.js';
+export { AbstractResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor/resourceEditorInput';
+export { AbstractTextResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor/textResourceEditorInput';
 import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
 export { Parts } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
 import { StandaloneServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+export { SplitView } from 'vscode/vscode/vs/base/browser/ui/splitview/splitview';
+import { fakeActiveGroup } from './editor.js';
 import { withReadyServices } from 'vscode/services';
 
 class InjectedEditorPane extends EditorPane {
     constructor(id) {
-        super(id, StandaloneServices.get(ITelemetryService), StandaloneServices.get(IThemeService), StandaloneServices.get(IStorageService));
+        super(id, fakeActiveGroup, StandaloneServices.get(ITelemetryService), StandaloneServices.get(IThemeService), StandaloneServices.get(IStorageService));
     }
 }
 class SimpleEditorPane extends InjectedEditorPane {

package/tools.js

@@ -0,0 +1,5 @@
+function unsupported() {
+    throw new Error('unsupported');
+}
+
+export { unsupported };

package/vscode/src/vs/workbench/browser/layout.js

@@ -1,6 +1,6 @@
 import { Disposable, DisposableStore, toDisposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { getClientArea, getActiveDocument, getWindows, getWindow, addDisposableListener, EventType, isActiveDocument, getWindowId, getActiveWindow, getActiveElement, isAncestorUsingFlowTo, focusWindow, position, size, computeScreenAwareSize } from 'vscode/vscode/vs/base/browser/dom';
+import { getClientArea, getActiveDocument, getWindows, getWindow, addDisposableListener, EventType, isActiveDocument, getWindowId, getActiveWindow, getActiveElement, isAncestorUsingFlowTo, position, size, computeScreenAwareSize } from 'vscode/vscode/vs/base/browser/dom';
 import { onDidChangeFullscreen, isFullscreen, isWCOEnabled } from 'vscode/vscode/vs/base/browser/browser';
 import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
 import { isWindows, isLinux, isWeb, isIOS, isMacintosh } from 'vscode/vscode/vs/base/common/platform';
@@ -79,6 +79,9 @@ class Layout extends Disposable {
             return targetDocument.body.getElementsByClassName('monaco-workbench')[0];
         }
     }
+    whenContainerStylesLoaded(window) {
+        return this.containerStylesLoaded.get(window.vscodeWindowId);
+    }
     get mainContainerDimension() { return this._mainContainerDimension; }
     get activeContainerDimension() {
         return this.getContainerDimension(this.activeContainer);
@@ -97,10 +100,6 @@ class Layout extends Disposable {
     get activeContainerOffset() {
         return this.computeContainerOffset(getWindow(this.activeContainer));
     }
-    get whenActiveContainerStylesLoaded() {
-        const active = this.activeContainer;
-        return this.auxWindowStylesLoaded.get(active) || Promise.resolve();
-    }
     computeContainerOffset(targetWindow) {
         let top = 0;
         let quickPickTop = 0;
@@ -147,8 +146,8 @@ class Layout extends Disposable {
         this._onDidChangeActiveContainer = this._register(( new Emitter()));
         this.onDidChangeActiveContainer = this._onDidChangeActiveContainer.event;
         this.mainContainer = document.createElement('div');
+        this.containerStylesLoaded = ( new Map());
         this.parts = ( new Map());
-        this.auxWindowStylesLoaded = ( new Map());
         this.initialized = false;
         this.disposed = false;
         this._openedDefaultEditors = false;
@@ -199,9 +198,13 @@ class Layout extends Disposable {
                 LegacyWorkbenchLayoutSettings.SIDEBAR_POSITION,
                 LegacyWorkbenchLayoutSettings.STATUSBAR_VISIBLE,
             ].some(setting => e.affectsConfiguration(setting)))) {
-                const activityBarMovedToTop = e.affectsConfiguration("workbench.activityBar.location" ) && this.configurationService.getValue("workbench.activityBar.location" ) === "top" ;
                 const editorActionsMovedToTitlebar = e.affectsConfiguration("workbench.editor.editorActionsLocation" ) && this.configurationService.getValue("workbench.editor.editorActionsLocation" ) === "titleBar" ;
-                if (activityBarMovedToTop || editorActionsMovedToTitlebar) {
+                let activityBarMovedToTopOrBottom = false;
+                if (e.affectsConfiguration("workbench.activityBar.location" )) {
+                    const activityBarPosition = this.configurationService.getValue("workbench.activityBar.location" );
+                    activityBarMovedToTopOrBottom = activityBarPosition === "top"  || activityBarPosition === "bottom" ;
+                }
+                if (activityBarMovedToTopOrBottom || editorActionsMovedToTitlebar) {
                     if (this.configurationService.getValue("window.customTitleBarVisibility" ) === "never" ) {
                         this.configurationService.updateValue("window.customTitleBarVisibility" , "auto" );
                     }
@@ -225,11 +228,13 @@ class Layout extends Disposable {
             this._register(addDisposableListener(navigator.windowControlsOverlay, 'geometrychange', () => this.onDidChangeWCO()));
         }
         this._register(this.auxiliaryWindowService.onDidOpenAuxiliaryWindow(({ window, disposables }) => {
+            const windowId = window.window.vscodeWindowId;
+            this.containerStylesLoaded.set(windowId, window.whenStylesHaveLoaded);
+            window.whenStylesHaveLoaded.then(() => this.containerStylesLoaded.delete(windowId));
+            disposables.add(toDisposable(() => this.containerStylesLoaded.delete(windowId)));
             const eventDisposables = disposables.add(( new DisposableStore()));
-            this.auxWindowStylesLoaded.set(window.container, window.whenStylesHaveLoaded);
             this._onDidAddContainer.fire({ container: window.container, disposables: eventDisposables });
             disposables.add(window.onDidLayout(dimension => this.handleContainerDidLayout(window.container, dimension)));
-            disposables.add(toDisposable(() => this.auxWindowStylesLoaded.delete(window.container)));
         }));
     }
     onMenubarToggled(visible) {
@@ -418,7 +423,7 @@ class Layout extends Disposable {
         };
         if (this.isVisible("workbench.parts.sidebar" )) {
             let viewContainerToRestore;
-            if (!this.environmentService.isBuilt || lifecycleService.startupKind === 3  || isWeb) {
+            if (!this.environmentService.isBuilt || lifecycleService.startupKind === 3 ) {
                 viewContainerToRestore = this.storageService.get(SidebarPart.activeViewletSettingsKey, 1 , this.viewDescriptorService.getDefaultViewContainer(0 )?.id);
             }
             else {
@@ -698,7 +703,9 @@ class Layout extends Disposable {
         });
     }
     registerPart(part) {
-        this.parts.set(part.getId(), part);
+        const id = part.getId();
+        this.parts.set(id, part);
+        return toDisposable(() => this.parts.delete(id));
     }
     getPart(key) {
         const part = this.parts.get(key);
@@ -723,9 +730,6 @@ class Layout extends Disposable {
     }
     focusPart(part, targetWindow = mainWindow) {
         const container = this.getContainer(targetWindow, part) ?? this.mainContainer;
-        if (container) {
-            focusWindow(container);
-        }
         switch (part) {
             case "workbench.parts.editor" :
                 this.editorGroupService.getPart(container).activeGroup.focus();
@@ -1946,7 +1950,7 @@ class LayoutStateModel extends Disposable {
         LayoutStateKeys.GRID_SIZE.defaultValue = { height: workbenchDimensions.height, width: workbenchDimensions.width };
         LayoutStateKeys.SIDEBAR_SIZE.defaultValue = Math.min(300, workbenchDimensions.width / 4);
         LayoutStateKeys.AUXILIARYBAR_SIZE.defaultValue = Math.min(300, workbenchDimensions.width / 4);
-        LayoutStateKeys.PANEL_SIZE.defaultValue = (this.stateCache.get(LayoutStateKeys.PANEL_POSITION.name) ?? LayoutStateKeys.PANEL_POSITION.defaultValue) === 'bottom' ? workbenchDimensions.height / 3 : workbenchDimensions.width / 4;
+        LayoutStateKeys.PANEL_SIZE.defaultValue = (this.stateCache.get(LayoutStateKeys.PANEL_POSITION.name) ?? LayoutStateKeys.PANEL_POSITION.defaultValue) === 2  ? workbenchDimensions.height / 3 : workbenchDimensions.width / 4;
         LayoutStateKeys.SIDEBAR_HIDDEN.defaultValue = this.contextService.getWorkbenchState() === 1 ;
         for (key in LayoutStateKeys) {
             const stateKey = LayoutStateKeys[key];
@@ -2021,7 +2025,7 @@ class LayoutStateModel extends Disposable {
         if (oldValue !== undefined) {
             return !oldValue;
         }
-        return this.configurationService.getValue("workbench.activityBar.location" ) !== "side" ;
+        return this.configurationService.getValue("workbench.activityBar.location" ) !== "default" ;
     }
     setRuntimeValueAndFire(key, value) {
         const previousValue = this.stateCache.get(key.name);

package/vscode/src/vs/workbench/browser/workbench.js

@@ -1,3 +1,4 @@
+import 'vscode/vscode/vs/workbench/browser/style';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { addDisposableListener, runWhenWindowIdle } from 'vscode/vscode/vs/base/browser/dom';
 import { Emitter, setGlobalLeakWarningThreshold, Event } from 'vscode/vscode/vs/base/common/event';
@@ -30,7 +31,7 @@ import '../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
 import { PixelRatio } from 'vscode/vscode/vs/base/browser/pixelRatio';
 import { WorkbenchHoverDelegate } from 'vscode/vscode/vs/platform/hover/browser/hover';
-import { setHoverDelegateFactory } from 'vscode/vscode/vs/base/browser/ui/hover/hoverDelegate';
+import { setHoverDelegateFactory } from 'vscode/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
 import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
 
 class Workbench extends Layout {
@@ -83,7 +84,7 @@ class Workbench extends Layout {
     }
     startup() {
         try {
-            setGlobalLeakWarningThreshold(175);
+            this._register(setGlobalLeakWarningThreshold(175));
             const instantiationService = this.initServices(this.serviceCollection);
             instantiationService.invokeFunction(accessor => {
                 const lifecycleService = accessor.get(ILifecycleService);

package/workbench.js

@@ -38,7 +38,6 @@ import { ProgressService } from 'vscode/vscode/vs/workbench/services/progress/br
 import { PaneCompositePartService } from 'vscode/vscode/vs/workbench/browser/parts/paneCompositePartService';
 import { IAuxiliaryWindowService, BrowserAuxiliaryWindowService } from 'vscode/vscode/vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService';
 import { ViewsService } from 'vscode/vscode/vs/workbench/services/views/browser/viewsService';
-import { HoverService } from 'vscode/vscode/vs/editor/browser/services/hoverService';
 import { IHoverService } from 'vscode/vscode/vs/platform/hover/browser/hover';
 import { EditorService } from 'vscode/vscode/vs/workbench/services/editor/browser/editorService';
 import { EditorParts } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorParts';
@@ -49,6 +48,7 @@ import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
 import { setFullscreen } from 'vscode/vscode/vs/base/browser/browser';
 import { EditorPaneService } from 'vscode/vscode/vs/workbench/services/editor/browser/editorPaneService';
 import { IEditorPaneService } from 'vscode/vscode/vs/workbench/services/editor/common/editorPaneService';
+import { ICustomEditorLabelService, CustomEditorLabelService } from 'vscode/vscode/vs/workbench/services/editor/common/customEditorLabelService';
 import getServiceOverride$3 from '@codingame/monaco-vscode-keybindings-service-override';
 import getServiceOverride$2 from '@codingame/monaco-vscode-quickaccess-service-override';
 import getServiceOverride$1 from '@codingame/monaco-vscode-bulk-edit-service-override';
@@ -79,8 +79,10 @@ import 'vscode/vscode/vs/workbench/browser/parts/editor/editor.autosave.contribu
 import 'vscode/vscode/vs/workbench/contrib/files/browser/files.editorPane.contribution';
 import 'vscode/vscode/vs/workbench/contrib/files/browser/fileCommands.save';
 import 'vscode/vscode/vs/workbench/browser/actions/navigationActions';
+import 'vscode/vscode/vs/workbench/browser/style';
 import './tools/editorAssets.js';
 export { EditorPane, SimpleEditorInput, SimpleEditorPane, getPanelPosition, getSideBarPosition, isPartVisibile, onDidChangePanelPosition, onDidChangeSideBarPosition, registerCustomView, registerEditor, registerEditorPane, registerEditorSerializer, setPartVisibility, viewContainerRegistry, viewRegistry } from './tools/views.js';
+import { HoverService } from 'vscode/vscode/vs/editor/browser/services/hoverService/hoverService';
 export { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
 export { ConfirmResult } from './override/vs/platform/dialogs/common/dialogs.js';
 export { AbstractResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor/resourceEditorInput';
@@ -163,6 +165,7 @@ function getServiceOverride(options, _webviewIframeAlternateDomains) {
         [( IProgressService.toString())]: new SyncDescriptor(ProgressService, [], true),
         [( IAuxiliaryWindowService.toString())]: new SyncDescriptor(BrowserAuxiliaryWindowService, [], true),
         [( IEditorPaneService.toString())]: new SyncDescriptor(EditorPaneService, [], true),
+        [( ICustomEditorLabelService.toString())]: new SyncDescriptor(CustomEditorLabelService, [], true),
         ...getServiceOverride$4(),
         ...getServiceOverride$5(),
         ...getServiceOverride$6()