@codingame/monaco-vscode-api 1.81.6 → 1.81.7-next.0

package/dist/service-override/tools/editor.js

@@ -1,11 +1,27 @@
+import { __decorate, __param } from '../../node_modules/tslib/tslib.es6.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
 import { isPreferredGroup, SIDE_GROUP } from '../../vscode/vs/workbench/services/editor/common/editorService.js';
-import { isResourceEditorInput, isEditorInput } from '../../vscode/vs/workbench/common/editor.js';
+import { EditorCloseContext, isResourceEditorInput, isEditorInput } from '../../vscode/vs/workbench/common/editor.js';
 import { applyTextEditorOptions } from '../../vscode/vs/workbench/common/editor/editorOptions.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { DEFAULT_EDITOR_MIN_DIMENSIONS, DEFAULT_EDITOR_MAX_DIMENSIONS } from '../../vscode/vs/workbench/browser/parts/editor/editor.js';
-import { StandaloneEditor } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { StandaloneCodeEditor, StandaloneEditor } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { EditorService } from '../../vscode/vs/workbench/services/editor/browser/editorService.js';
+import { IEditorGroupsService } from '../../vscode/vs/workbench/services/editor/common/editorGroupsService.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IWorkspaceTrustRequestService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { IEditorResolverService } from '../../vscode/vs/workbench/services/editor/common/editorResolverService.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ITextEditorService } from '../../vscode/vs/workbench/services/textfile/common/textEditorService.js';
+import { IHostService } from '../../vscode/vs/workbench/services/host/browser/host.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { TextResourceEditorInput } from '../../vscode/vs/workbench/common/editor/textResourceEditorInput.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { unsupported } from '../../tools.js';
 class SimpleEditorPane {
     constructor(editor) {
@@ -69,4 +85,356 @@ function wrapOpenEditor(textModelService, defaultBehavior, fallbackBahavior) {
     }
     return openEditor;
 }
-export { wrapOpenEditor };
+let MonacoEditorService = class MonacoEditorService extends EditorService {
+    constructor(_openEditorFallback, _isEditorPartVisible, _editorGroupService, instantiationService, fileService, configurationService, contextService, uriIdentityService, editorResolverService, workspaceTrustRequestService, hostService, textEditorService, textModelService) {
+        super(_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 = class StandaloneEditorGroup extends Disposable {
+    constructor(editor, instantiationService, scopedContextKeyService) {
+        super();
+        this.editor = editor;
+        this.scopedContextKeyService = scopedContextKeyService;
+        this.active = false;
+        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.idCounter;
+        this.index = -1;
+        this.label = `standalone editor ${this.editor.getId()}`;
+        this.ariaLabel = `standalone editor ${this.editor.getId()}`;
+        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 = unsupported;
+        this.openEditors = unsupported;
+        this.isPinned = () => false;
+        this.isSticky = () => false;
+        this.isActive = () => this.editor.hasWidgetFocus();
+        this.contains = unsupported;
+        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 = unsupported;
+        this.stickEditor = unsupported;
+        this.unstickEditor = unsupported;
+        this.lock = unsupported;
+        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: 3 ,
+                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: 4 ,
+                    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 titleHeight() { return unsupported(); }
+    setActive(isActive) {
+        this.active = isActive;
+    }
+    get element() { return unsupported(); }
+    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();
+    }
+};
+StandaloneEditorGroup.idCounter = 0;
+StandaloneEditorGroup = __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._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.onDidLayout = this.delegate.onDidLayout;
+        this.onDidScroll = this.delegate.onDidScroll;
+        this.onDidChangeGroupIndex = this.delegate.onDidChangeGroupIndex;
+        this.onDidChangeGroupLocked = this.delegate.onDidChangeGroupLocked;
+        this.getLayout = () => {
+            return this.delegate.getLayout();
+        };
+        this.getGroups = (order) => {
+            return [...this.additionalGroups, ...this.delegate.getGroups(order)];
+        };
+        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.centerLayout = (...args) => {
+            return this.delegate.centerLayout(...args);
+        };
+        this.isLayoutCentered = (...args) => {
+            return this.delegate.isLayoutCentered(...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.enforcePartOptions = (...args) => {
+            return this.delegate.enforcePartOptions(...args);
+        };
+        this.onDidChangeEditorPartOptions = this.delegate.onDidChangeEditorPartOptions;
+        setTimeout(() => {
+            const codeEditorService = StandaloneServices.get(ICodeEditorService);
+            const handleCodeEditor = (editor) => {
+                if (editor instanceof StandaloneEditor) {
+                    const onEditorFocused = () => {
+                        this.activeGroupOverride = this.additionalGroups.find(group => group.editor === editor);
+                        this._onDidChangeActiveGroup.fire(this.activeGroup);
+                    };
+                    editor.onDidFocusEditorText(onEditorFocused);
+                    editor.onDidFocusEditorWidget(onEditorFocused);
+                    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 groups() {
+        return [...this.additionalGroups, ...this.delegate.groups];
+    }
+    get activeGroup() {
+        return this.activeGroupOverride ?? this.delegate.activeGroup;
+    }
+    get contentDimension() { return this.delegate.contentDimension; }
+    get sideGroup() { return this.delegate.sideGroup; }
+    get count() { return this.delegate.count + this.additionalGroups.length; }
+    get orientation() { return this.delegate.orientation; }
+    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 partOptions() { return this.delegate.partOptions; }
+};
+MonacoDelegateEditorGroupsService = __decorate([
+    ( __param(1, IInstantiationService))
+], MonacoDelegateEditorGroupsService);
+export { MonacoDelegateEditorGroupsService, MonacoEditorService, wrapOpenEditor };

package/dist/service-override/views.d.ts

@@ -1,18 +1,18 @@
+import { IDisposable } from '../vscode/vs/base/common/lifecycle.js';
+export { IReference } from '../vscode/vs/base/common/lifecycle.js';
+import { ServicesAccessor } from '../vscode/vs/platform/instantiation/common/instantiation.js';
+export { IEditorOptions } from '../vscode/vs/platform/editor/common/editor.js';
+import { IEditorCloseHandler, EditorInput } from '../vscode/vs/workbench/common/editor/editorInput.js';
+export { IResolvedTextEditorModel } from '../vscode/vs/editor/common/services/resolverService.js';
 import { IEditorOverrideServices } from '../vscode/vs/editor/standalone/browser/standaloneServices.js';
 import { ViewContainerLocation } from '../vscode/vs/workbench/common/views.js';
-import { ServicesAccessor } from '../vscode/vs/platform/instantiation/common/instantiation.js';
 export { SidebarPart } from '../vscode/vs/workbench/browser/parts/sidebar/sidebarPart.js';
 export { ActivityService } from '../vscode/vs/workbench/services/activity/browser/activityService.js';
 export { ActivitybarPart } from '../vscode/vs/workbench/browser/parts/activitybar/activitybarPart.js';
-import { IDisposable } from '../vscode/vs/base/common/lifecycle.js';
-export { IReference } from '../vscode/vs/base/common/lifecycle.js';
 export { HoverService } from '../vscode/vs/workbench/services/hover/browser/hoverService.js';
 export { PanelPart } from '../vscode/vs/workbench/browser/parts/panel/panelPart.js';
 import { Part } from '../vscode/vs/workbench/browser/part.js';
-export { IEditorOptions } from '../vscode/vs/platform/editor/common/editor.js';
 import { Codicon } from '../vscode/vs/base/common/codicons.js';
-import { IEditorCloseHandler, EditorInput } from '../vscode/vs/workbench/common/editor/editorInput.js';
-export { IResolvedTextEditorModel } from '../vscode/vs/editor/common/services/resolverService.js';
 export { StatusbarPart } from '../vscode/vs/workbench/browser/parts/statusbar/statusbarPart.js';
 import { Parts } from '../vscode/vs/workbench/services/layout/browser/layoutService.js';
 export { ConfirmResult } from '../vscode/vs/platform/dialogs/common/dialogs.js';

package/dist/service-override/views.js

@@ -46,7 +46,6 @@ import '../vscode/vs/workbench/contrib/files/browser/files.contribution2.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { IEditorGroupsService } from '../vscode/vs/workbench/services/editor/common/editorGroupsService.js';
 import { IEditorDropService } from '../vscode/vs/workbench/services/editor/browser/editorDropService.js';
-import { EditorService } from '../vscode/vs/workbench/services/editor/browser/editorService.js';
 import { IEditorService } from '../vscode/vs/workbench/services/editor/common/editorService.js';
 import { IEditorResolverService } from '../vscode/vs/workbench/services/editor/common/editorResolverService.js';
 import { EditorResolverService } from '../vscode/vs/workbench/services/editor/browser/editorResolverService.js';
@@ -56,13 +55,6 @@ import { ContextViewService } from 'monaco-editor/esm/vs/platform/contextview/br
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
 import { EditorInput } from '../vscode/vs/workbench/common/editor/editorInput.js';
 import { EditorExtensions } from '../vscode/vs/workbench/common/editor.js';
-import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { IWorkspaceTrustRequestService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
-import { IHostService } from '../vscode/vs/workbench/services/host/browser/host.js';
 import { ITextEditorService, TextEditorService } from '../vscode/vs/workbench/services/textfile/common/textEditorService.js';
 import { CodeEditorService } from '../vscode/vs/workbench/services/editor/browser/codeEditorService.js';
 import { IUntitledTextEditorService, UntitledTextEditorService } from '../vscode/vs/workbench/services/untitled/common/untitledTextEditorService.js';
@@ -93,8 +85,7 @@ import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/st
 import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 export { ConfirmResult } from '../override/vs/platform/dialogs/common/dialogs.js';
 import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
-import { StandaloneCodeEditor } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
-import { wrapOpenEditor } from './tools/editor.js';
+import { MonacoEditorService, MonacoDelegateEditorGroupsService } from './tools/editor.js';
 import getServiceOverride$2 from './bulkEdit.js';
 import getServiceOverride$1 from './layout.js';
 import getServiceOverride$3 from './quickaccess.js';
@@ -367,38 +358,76 @@ function isEditorPartVisible() {
     const container = StandaloneServices.get(IEditorGroupsService).getContainer();
     return container != null && isElementVisible(container);
 }
-let MonacoEditorService = class MonacoEditorService extends EditorService {
-    constructor(_openEditorFallback, _editorGroupService, instantiationService, fileService, configurationService, contextService, uriIdentityService, editorResolverService, workspaceTrustRequestService, hostService, textEditorService, textModelService) {
-        super(_editorGroupService, instantiationService, fileService, configurationService, contextService, uriIdentityService, editorResolverService, workspaceTrustRequestService, hostService, textEditorService);
-        this.openEditor = wrapOpenEditor(textModelService, this.openEditor.bind(this), _openEditorFallback);
+let MonacoEditorPart = class MonacoEditorPart extends MonacoDelegateEditorGroupsService {
+    constructor(instantiationService) {
+        super(instantiationService.createInstance(EditorPart), instantiationService);
+        this.onDidChangeSizeConstraints = this.delegate.onDidChangeSizeConstraints;
+        this.restoreGroup = (...args) => {
+            return this.delegate.restoreGroup(...args);
+        };
+        this.isGroupMaximized = (...args) => {
+            return this.delegate.isGroupMaximized(...args);
+        };
+        this.createEditorDropTarget = (...args) => {
+            return this.delegate.createEditorDropTarget(...args);
+        };
+        this.updateStyles = (...args) => {
+            return this.delegate.updateStyles(...args);
+        };
+        this.setBoundarySashes = (...args) => {
+            return this.delegate.setBoundarySashes(...args);
+        };
+        this.layout = (...args) => {
+            return this.delegate.layout(...args);
+        };
+        this.toJSON = (...args) => {
+            return this.delegate.toJSON(...args);
+        };
+        this.onDidVisibilityChange = this.delegate.onDidVisibilityChange;
+        this.create = (...args) => {
+            return this.delegate.create(...args);
+        };
+        this.getContainer = (...args) => {
+            return this.delegate.getContainer(...args);
+        };
+        this.setVisible = (...args) => {
+            return this.delegate.setVisible(...args);
+        };
+        this.getId = (...args) => {
+            return this.delegate.getId(...args);
+        };
     }
-    get activeTextEditorControl() {
-        const focusedCodeEditor = StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor();
-        if (focusedCodeEditor != null && focusedCodeEditor instanceof StandaloneCodeEditor) {
-            return focusedCodeEditor;
-        }
-        return super.activeTextEditorControl;
+    get minimumWidth() {
+        return this.delegate.minimumWidth;
     }
-    async openEditor(editor, optionsOrPreferredGroup, preferredGroup) {
-        if (!isEditorPartVisible()) {
-            return undefined;
-        }
-        return super.openEditor(editor, optionsOrPreferredGroup, preferredGroup);
+    get maximumWidth() {
+        return this.delegate.maximumWidth;
+    }
+    get minimumHeight() {
+        return this.delegate.minimumHeight;
+    }
+    get maximumHeight() {
+        return this.delegate.maximumHeight;
+    }
+    get snap() {
+        return this.delegate.snap;
+    }
+    get onDidChange() {
+        return this.delegate.onDidChange;
+    }
+    get priority() {
+        return this.delegate.priority;
+    }
+    get dimension() {
+        return this.delegate.dimension;
+    }
+    get element() {
+        return this.delegate.element;
     }
 };
-MonacoEditorService = __decorate([
-    ( __param(1, IEditorGroupsService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IFileService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IWorkspaceContextService)),
-    ( __param(6, IUriIdentityService)),
-    ( __param(7, IEditorResolverService)),
-    ( __param(8, IWorkspaceTrustRequestService)),
-    ( __param(9, IHostService)),
-    ( __param(10, ITextEditorService)),
-    ( __param(11, ITextModelService))
-], MonacoEditorService);
+MonacoEditorPart = __decorate([
+    ( __param(0, IInstantiationService))
+], MonacoEditorPart);
 let webviewIframeAlternateDomains;
 registerAssets({
     'vs/workbench/contrib/webview/browser/pre/service-worker.js': () => changeUrlDomain(new URL('../assets/service-worker.js', import.meta.url).href, webviewIframeAlternateDomains),
@@ -452,10 +481,10 @@ function getServiceOverride(openEditorFallback, _webviewIframeAlternateDomains)
         [( IExplorerService.toString())]: new SyncDescriptor(ExplorerService, [], true),
         [( ICodeEditorService.toString())]: new SyncDescriptor(CodeEditorService, [], true),
         [( ITextEditorService.toString())]: new SyncDescriptor(TextEditorService, [], false),
-        [( IEditorGroupsService.toString())]: new SyncDescriptor(EditorPart, [], false),
+        [( IEditorGroupsService.toString())]: new SyncDescriptor(MonacoEditorPart, [], false),
         [( IStatusbarService.toString())]: new SyncDescriptor(StatusbarPart, [], false),
         [( IEditorDropService.toString())]: new SyncDescriptor(EditorDropService, [], true),
-        [( IEditorService.toString())]: new SyncDescriptor(MonacoEditorService, [openEditorFallback], false),
+        [( IEditorService.toString())]: new SyncDescriptor(MonacoEditorService, [openEditorFallback, isEditorPartVisible], false),
         [( IEditorResolverService.toString())]: new SyncDescriptor(EditorResolverService, [], false),
         [( IBreadcrumbsService.toString())]: new SyncDescriptor(BreadcrumbsService, [], true),
         [( IContextViewService.toString())]: new SyncDescriptor(ContextViewService, [], true),

package/dist/vscode/vs/platform/workspace/common/workspaceTrust.d.ts

@@ -1,3 +1,7 @@
+import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
+import { Event } from '../../../base/common/event.js';
+import { URI } from '../../../base/common/uri.js';
+
 interface WorkspaceTrustRequestButton {
     readonly label: string;
     readonly type: 'ContinueWithTrust' | 'ContinueWithoutTrust' | 'Manage' | 'Cancel';
@@ -6,5 +10,23 @@ interface WorkspaceTrustRequestOptions {
     readonly buttons?: WorkspaceTrustRequestButton[];
     readonly message?: string;
 }
+declare const enum WorkspaceTrustUriResponse {
+    Open = 1,
+    OpenInNewWindow = 2,
+    Cancel = 3
+}
+declare const IWorkspaceTrustRequestService: ServiceIdentifier<IWorkspaceTrustRequestService>;
+interface IWorkspaceTrustRequestService {
+    readonly _serviceBrand: undefined;
+    readonly onDidInitiateOpenFilesTrustRequest: Event<void>;
+    readonly onDidInitiateWorkspaceTrustRequest: Event<WorkspaceTrustRequestOptions | undefined>;
+    readonly onDidInitiateWorkspaceTrustRequestOnStartup: Event<void>;
+    completeOpenFilesTrustRequest(result: WorkspaceTrustUriResponse, saveResponse?: boolean): Promise<void>;
+    requestOpenFilesTrust(openFiles: URI[]): Promise<WorkspaceTrustUriResponse>;
+    cancelWorkspaceTrustRequest(): void;
+    completeWorkspaceTrustRequest(trusted?: boolean): Promise<void>;
+    requestWorkspaceTrust(options?: WorkspaceTrustRequestOptions): Promise<boolean | undefined>;
+    requestWorkspaceTrustOnStartup(): void;
+}
 
-export { WorkspaceTrustRequestButton, WorkspaceTrustRequestOptions };
+export { IWorkspaceTrustRequestService, WorkspaceTrustRequestButton, WorkspaceTrustRequestOptions, WorkspaceTrustUriResponse };

package/dist/vscode/vs/workbench/browser/parts/editor/editor.d.ts

@@ -0,0 +1,20 @@
+import { IEditorIdentifier } from '../../../common/editor.js';
+import { Event } from '../../../../base/common/event.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+
+/**
+ * A sub-interface of IEditorService to hide some workbench-core specific
+ * events from clients.
+ */
+interface EditorServiceImpl extends IEditorService {
+    /**
+     * Emitted when an editor failed to open.
+     */
+    readonly onDidOpenEditorFail: Event<IEditorIdentifier>;
+    /**
+     * Emitted when the list of most recently active editors change.
+     */
+    readonly onDidMostRecentlyActiveEditorsChange: Event<void>;
+}
+
+export { EditorServiceImpl };