@codingame/monaco-vscode-views-service-override 11.1.2 → 12.0.0

package/index.d.ts

@@ -1,2 +1,34 @@
-export * from 'vscode/service-override/views';
-export { default } from 'vscode/service-override/views';
+import { type IEditorOverrideServices } from "vscode/vscode/vs/editor/standalone/browser/standaloneServices";
+import { SidebarPart } from "@codingame/monaco-vscode-6980eeab-47bb-5a48-8e15-32caf0785565-common/vscode/vs/workbench/browser/parts/sidebar/sidebarPart";
+import { ActivityService } from "@codingame/monaco-vscode-cc2b8dc7-d125-518e-bf7e-99a1db5babd1-common/vscode/vs/workbench/services/activity/browser/activityService";
+import { ActivitybarPart } from "@codingame/monaco-vscode-0cc5da60-f921-59b9-bd8c-a018e93c0a6f-common/vscode/vs/workbench/browser/parts/activitybar/activitybarPart";
+import type { IDisposable, IReference } from "vscode/vscode/vs/base/common/lifecycle";
+import { PanelPart } from "@codingame/monaco-vscode-6980eeab-47bb-5a48-8e15-32caf0785565-common/vscode/vs/workbench/browser/parts/panel/panelPart";
+import { Part } from "@codingame/monaco-vscode-d8236b3b-b91a-522d-89f4-94d70a546f6a-common/vscode/vs/workbench/browser/part";
+import { GroupOrientation } from "vscode/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import type { IEditorOptions } from "vscode/vscode/vs/platform/editor/common/editor";
+import type { IResolvedTextEditorModel } from "vscode/vscode/vs/editor/common/services/resolverService";
+import { Parts, Position } from "@codingame/monaco-vscode-e571cbbb-526b-5d8b-92c5-a0437d2dabb3-common/vscode/vs/workbench/services/layout/browser/layoutService";
+import type { ILayoutInitializationState } from "@codingame/monaco-vscode-workbench-service-override/vscode/vs/workbench/browser/layout";
+import { type OpenEditor } from "./service-override/tools/editor.js";
+export * from "./service-override/tools/views.js";
+declare function renderPart(partContainer: HTMLElement, part: Part): void;
+declare function attachPart(part: Parts, container: HTMLElement): IDisposable;
+declare function onPartVisibilityChange(part: Parts, listener: (visible: boolean) => void): IDisposable;
+declare function renderActivitybarPar(container: HTMLElement): IDisposable;
+declare function renderSidebarPart(container: HTMLElement): IDisposable;
+declare function renderPanelPart(container: HTMLElement): IDisposable;
+declare function renderAuxiliaryPart(container: HTMLElement): IDisposable;
+declare function renderEditorPart(container: HTMLElement): IDisposable;
+declare function renderStatusBarPart(container: HTMLElement): IDisposable;
+declare function isEditorPartVisible(): boolean;
+type InitializationStateTransformer = (state: ILayoutInitializationState) => ILayoutInitializationState;
+declare function getServiceOverride(openEditorFallback?: OpenEditor, _webviewIframeAlternateDomains?: string): IEditorOverrideServices;
+/**
+ * @deprecated Provide restoreEditors with the initializationState.editor.restoreEditors params
+ */
+declare function getServiceOverride(openEditorFallback?: OpenEditor, _webviewIframeAlternateDomains?: string, restoreEditors?: boolean): IEditorOverrideServices;
+declare function getServiceOverride(openEditorFallback?: OpenEditor, _webviewIframeAlternateDomains?: string, initializationState?: InitializationStateTransformer): IEditorOverrideServices;
+export default getServiceOverride;
+export { GroupOrientation, renderPart, renderSidebarPart, renderActivitybarPar, renderAuxiliaryPart, renderPanelPart, renderEditorPart, renderStatusBarPart, isEditorPartVisible, attachPart, onPartVisibilityChange, Position, ActivityService, SidebarPart, ActivitybarPart, PanelPart };
+export type { ILayoutInitializationState, InitializationStateTransformer, OpenEditor, IEditorOptions, IResolvedTextEditorModel, IReference };

package/index.js

@@ -1,18 +1,575 @@
-export { attachPart, default, isEditorPartVisible, onPartVisibilityChange, renderActivitybarPar, renderAuxiliaryPart, renderEditorPart, renderPanelPart, renderPart, renderSidebarPart, renderStatusBarPart } from './views.js';
-export { ActivityService } from 'vscode/vscode/vs/workbench/services/activity/browser/activityService';
-export { ActivitybarPart } from '@codingame/monaco-vscode-view-common-views-workbench-common/vscode/vs/workbench/browser/parts/activitybar/activitybarPart';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
+import { StandaloneServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { ViewContainerLocation } from 'vscode/vscode/vs/workbench/common/views';
+export { ViewContainerLocation } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views.service';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { SidebarPart } from '@codingame/monaco-vscode-6980eeab-47bb-5a48-8e15-32caf0785565-common/vscode/vs/workbench/browser/parts/sidebar/sidebarPart';
+export { SidebarPart } from '@codingame/monaco-vscode-6980eeab-47bb-5a48-8e15-32caf0785565-common/vscode/vs/workbench/browser/parts/sidebar/sidebarPart';
+export { ActivityService } from '@codingame/monaco-vscode-cc2b8dc7-d125-518e-bf7e-99a1db5babd1-common/vscode/vs/workbench/services/activity/browser/activityService';
+import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite.service';
+export { ActivitybarPart } from '@codingame/monaco-vscode-0cc5da60-f921-59b9-bd8c-a018e93c0a6f-common/vscode/vs/workbench/browser/parts/activitybar/activitybarPart';
+import { PanelPart } from '@codingame/monaco-vscode-6980eeab-47bb-5a48-8e15-32caf0785565-common/vscode/vs/workbench/browser/parts/panel/panelPart';
+export { PanelPart } from '@codingame/monaco-vscode-6980eeab-47bb-5a48-8e15-32caf0785565-common/vscode/vs/workbench/browser/parts/panel/panelPart';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import '@codingame/monaco-vscode-d8236b3b-b91a-522d-89f4-94d70a546f6a-common/vscode/vs/workbench/browser/part';
+import '@codingame/monaco-vscode-6980eeab-47bb-5a48-8e15-32caf0785565-common/vscode/vs/workbench/browser/parts/editor/editorPart';
+import { GroupsOrder } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
 export { GroupOrientation } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { pathsToEditors, isResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor';
 export { EditorInputCapabilities } from 'vscode/vscode/vs/workbench/common/editor';
-export { Parts, Position } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
-export { EditorPane, SimpleEditorInput, SimpleEditorPane, getPanelPosition, getSideBarPosition, isPartVisibile, onDidChangePanelPosition, onDidChangeSideBarPosition, registerCustomView, registerEditor, registerEditorPane, registerEditorSerializer, setPartVisibility, viewContainerRegistry, viewRegistry } from './tools/views.js';
-export { ViewContainerLocation } from 'vscode/vscode/vs/workbench/common/views';
-export { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
-export { ConfirmResult } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+import { Parts, Position, positionToString } from '@codingame/monaco-vscode-e571cbbb-526b-5d8b-92c5-a0437d2dabb3-common/vscode/vs/workbench/services/layout/browser/layoutService';
+export { Parts, Position } from '@codingame/monaco-vscode-e571cbbb-526b-5d8b-92c5-a0437d2dabb3-common/vscode/vs/workbench/services/layout/browser/layoutService';
+import { StorageScope } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { ILayoutService } from 'vscode/vscode/vs/platform/layout/browser/layoutService.service';
+import { StartupKind } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { AuxiliaryBarPart } from '@codingame/monaco-vscode-6980eeab-47bb-5a48-8e15-32caf0785565-common/vscode/vs/workbench/browser/parts/auxiliarybar/auxiliaryBarPart';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { mark } from 'vscode/vscode/vs/base/common/performance';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { Promises } from 'vscode/vscode/vs/base/common/async';
+import { isWeb } from 'vscode/vscode/vs/base/common/platform';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';
+import { isTemporaryWorkspace, WorkbenchState } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
+import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service';
+import { EditorParts } from '@codingame/monaco-vscode-6980eeab-47bb-5a48-8e15-32caf0785565-common/vscode/vs/workbench/browser/parts/editor/editorParts';
+import { MonacoDelegateEditorGroupsService, MonacoEditorService } from '@codingame/monaco-vscode-e97d19fd-ad95-5915-8104-6f1a86c7b652-common/service-override/tools/editor';
+import '@codingame/monaco-vscode-layout-service-override';
+import getServiceOverride$2 from '@codingame/monaco-vscode-quickaccess-service-override';
+import getServiceOverride$3 from '@codingame/monaco-vscode-keybindings-service-override';
+import getServiceOverride$1 from '@codingame/monaco-vscode-view-common-service-override';
+import { onRenderWorkbench } from 'vscode/lifecycle';
+import 'vscode/monaco';
+export { EditorPane, SimpleEditorInput, SimpleEditorPane, getPanelPosition, getSideBarPosition, isPartVisibile, onDidChangePanelPosition, onDidChangeSideBarPosition, registerCustomView, registerEditor, registerEditorPane, registerEditorSerializer, setPartVisibility, viewContainerRegistry, viewRegistry } from '@codingame/monaco-vscode-0ccdeafc-77d6-5aa8-b465-b7d03b8fb10f-common/service-override/tools/views';
+export { ViewPaneContainer } from '@codingame/monaco-vscode-9e888134-1a6f-58d9-b0e6-0fc047448366-common/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
+export { ConfirmResult } from '@codingame/monaco-vscode-d6e33d82-c101-549d-a885-0807ab3e0cfb-common/vscode/vs/platform/dialogs/common/dialogs';
 export { RegisteredEditorPriority } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
-export { AbstractResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor/resourceEditorInput';
-export { AbstractTextResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor/textResourceEditorInput';
+export { AbstractResourceEditorInput } from '@codingame/monaco-vscode-0139c6af-2375-559c-af57-b738f2fd6d8e-common/vscode/vs/workbench/common/editor/resourceEditorInput';
+export { AbstractTextResourceEditorInput } from '@codingame/monaco-vscode-0139c6af-2375-559c-af57-b738f2fd6d8e-common/vscode/vs/workbench/common/editor/textResourceEditorInput';
 export { EditorInput } from 'vscode/vscode/vs/workbench/common/editor/editorInput';
 export { SplitView } from 'vscode/vscode/vs/base/browser/ui/splitview/splitview';
 export { DomScrollableElement } from 'vscode/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
-export { PanelPart } from '@codingame/monaco-vscode-view-common-views-workbench-common/vscode/vs/workbench/browser/parts/panel/panelPart';
-export { SidebarPart } from '@codingame/monaco-vscode-view-common-views-workbench-common/vscode/vs/workbench/browser/parts/sidebar/sidebarPart';
+
+function createPart(id, role, classes) {
+    const part = document.createElement(role === 'status' ? 'footer'  : 'div');
+    part.classList.add('part', 'monaco-workbench-part', ...classes);
+    part.id = id;
+    part.setAttribute('role', role);
+    if (role === 'status') {
+        part.setAttribute('aria-live', 'off');
+    }
+    return part;
+}
+function layoutPart(part) {
+    const parent = part.getContainer()?.parentNode;
+    if (parent == null) {
+        return;
+    }
+    part.layout(Math.max(part.minimumWidth, Math.min(part.maximumWidth, parent.offsetWidth)), Math.max(part.minimumHeight, Math.min(part.maximumHeight, parent.offsetHeight)), parent.offsetTop, parent.offsetLeft);
+}
+function renderPart(partContainer, part) {
+    partContainer.oncontextmenu = () => false;
+    function layout() {
+        layoutPart(part);
+    }
+    part.onDidVisibilityChange((visible) => {
+        if (visible) {
+            layout();
+        }
+    });
+    layout();
+}
+function getPart(part) {
+    return StandaloneServices.get(ILayoutService).getPart(part);
+}
+function _attachPart(part, container) {
+    container.append(part.getContainer());
+    const observer = new ResizeObserver(() => layoutPart(part));
+    observer.observe(container);
+    return {
+        dispose() {
+            return observer.disconnect();
+        }
+    };
+}
+function attachPart(part, container) {
+    const _part = getPart(part);
+    if (_part == null) {
+        throw new Error('Part not found');
+    }
+    return _attachPart(_part, container);
+}
+function onPartVisibilityChange(part, listener) {
+    const _part = getPart(part);
+    if (_part == null) {
+        throw new Error('Part not found');
+    }
+    return _part.onDidVisibilityChange(listener);
+}
+function renderActivitybarPar(container) {
+    return attachPart(Parts.ACTIVITYBAR_PART, container);
+}
+function renderSidebarPart(container) {
+    return attachPart(Parts.SIDEBAR_PART, container);
+}
+function renderPanelPart(container) {
+    return attachPart(Parts.PANEL_PART, container);
+}
+function renderAuxiliaryPart(container) {
+    return attachPart(Parts.AUXILIARYBAR_PART, container);
+}
+function renderEditorPart(container) {
+    return attachPart(Parts.EDITOR_PART, container);
+}
+function renderStatusBarPart(container) {
+    return attachPart(Parts.STATUSBAR_PART, container);
+}
+function isElementVisible(el) {
+    if (!el.isConnected) {
+        return false;
+    }
+    if (el.checkVisibility != null) {
+        return el.checkVisibility({
+            checkOpacity: true,
+            checkVisibilityCSS: true
+        });
+    }
+    return el.offsetHeight > 0 && el.offsetWidth > 0;
+}
+function isEditorPartVisible() {
+    const container = StandaloneServices.get(IEditorGroupsService).mainPart.getContainer();
+    return container != null && isElementVisible(container);
+}
+let MonacoEditorParts = class MonacoEditorParts extends MonacoDelegateEditorGroupsService {
+    constructor(instantiationService) {
+        super(instantiationService.createInstance(EditorParts), false, instantiationService);
+        this.restoreGroup = (...args) => {
+            return this.delegate.restoreGroup(...args);
+        };
+    }
+    getId() {
+        return 'standalone';
+    }
+    updateStyles() { }
+    registerPart(part) {
+        return this.delegate.registerPart(part);
+    }
+    bind(contextKey, group) {
+        return this.delegate.bind(contextKey, group);
+    }
+    get activePart() {
+        return this.delegate.activePart;
+    }
+};
+MonacoEditorParts = __decorate([
+    __param(0, IInstantiationService)
+], MonacoEditorParts);
+let transformInitializationState = (state) => state;
+onRenderWorkbench(async (accessor) => {
+    const paneCompositePartService = accessor.get(IPaneCompositePartService);
+    const viewDescriptorService = accessor.get(IViewDescriptorService);
+    const lifecycleService = accessor.get(ILifecycleService);
+    const storageService = accessor.get(IStorageService);
+    const editorGroupService = accessor.get(IEditorGroupsService);
+    const editorService = accessor.get(IEditorService);
+    const logService = accessor.get(ILogService);
+    const extensionService = accessor.get(IExtensionService);
+    const environmentService = accessor.get(IEnvironmentService);
+    const contextService = accessor.get(IWorkspaceContextService);
+    const configurationService = accessor.get(IConfigurationService);
+    const fileService = accessor.get(IFileService);
+    const workingCopyBackupService = accessor.get(IWorkingCopyBackupService);
+    const layoutService = accessor.get(ILayoutService);
+    function getInitialEditorsState() {
+        const defaultLayout = environmentService.options?.defaultLayout;
+        if (((defaultLayout?.editors != null && defaultLayout.editors.length > 0) ||
+            defaultLayout?.layout?.editors != null) &&
+            ((defaultLayout.force ?? false) || storageService.isNew(StorageScope.WORKSPACE))) {
+            return {
+                layout: defaultLayout.layout?.editors,
+                filesToOpenOrCreate: defaultLayout.editors?.map((editor) => {
+                    return {
+                        viewColumn: editor.viewColumn,
+                        fileUri: URI.revive(editor.uri),
+                        openOnlyIfExists: editor.openOnlyIfExists,
+                        options: editor.options
+                    };
+                })
+            };
+        }
+        const { filesToOpenOrCreate, filesToDiff, filesToMerge } = environmentService;
+        if (filesToOpenOrCreate != null || filesToDiff != null || filesToMerge != null) {
+            return { filesToOpenOrCreate, filesToDiff, filesToMerge };
+        }
+        return undefined;
+    }
+    function getDefaultLayoutViews(environmentService, storageService) {
+        const defaultLayout = environmentService.options?.defaultLayout;
+        if (defaultLayout == null) {
+            return undefined;
+        }
+        if (!(defaultLayout.force ?? false) && !storageService.isNew(StorageScope.WORKSPACE)) {
+            return undefined;
+        }
+        const { views } = defaultLayout;
+        if (views != null && views.length > 0) {
+            return views.map((view) => view.id);
+        }
+        return undefined;
+    }
+    function shouldRestoreEditors(contextService, initialEditorsState) {
+        if (isTemporaryWorkspace(contextService.getWorkspace())) {
+            return false;
+        }
+        const forceRestoreEditors = configurationService.getValue('window.restoreWindows') === 'preserve';
+        return !!forceRestoreEditors || initialEditorsState === undefined;
+    }
+    async function resolveEditorsToOpen(fileService, initialEditorsState) {
+        if (initialEditorsState != null) {
+            const filesToMerge = coalesce(await pathsToEditors(initialEditorsState.filesToMerge, fileService, logService));
+            if (filesToMerge.length === 4 &&
+                isResourceEditorInput(filesToMerge[0]) &&
+                isResourceEditorInput(filesToMerge[1]) &&
+                isResourceEditorInput(filesToMerge[2]) &&
+                isResourceEditorInput(filesToMerge[3])) {
+                return [
+                    {
+                        editor: {
+                            input1: { resource: filesToMerge[0].resource },
+                            input2: { resource: filesToMerge[1].resource },
+                            base: { resource: filesToMerge[2].resource },
+                            result: { resource: filesToMerge[3].resource },
+                            options: { pinned: true }
+                        }
+                    }
+                ];
+            }
+            const filesToDiff = coalesce(await pathsToEditors(initialEditorsState.filesToDiff, fileService, logService));
+            if (filesToDiff.length === 2) {
+                return [
+                    {
+                        editor: {
+                            original: { resource: filesToDiff[0].resource },
+                            modified: { resource: filesToDiff[1].resource },
+                            options: { pinned: true }
+                        }
+                    }
+                ];
+            }
+            const filesToOpenOrCreate = [];
+            const resolvedFilesToOpenOrCreate = await pathsToEditors(initialEditorsState.filesToOpenOrCreate, fileService, logService);
+            for (let i = 0; i < resolvedFilesToOpenOrCreate.length; i++) {
+                const resolvedFileToOpenOrCreate = resolvedFilesToOpenOrCreate[i];
+                if (resolvedFileToOpenOrCreate != null) {
+                    filesToOpenOrCreate.push({
+                        editor: resolvedFileToOpenOrCreate,
+                        viewColumn: initialEditorsState.filesToOpenOrCreate?.[i].viewColumn
+                    });
+                }
+            }
+            return filesToOpenOrCreate;
+        }
+        else if (contextService.getWorkbenchState() === WorkbenchState.EMPTY &&
+            configurationService.getValue('workbench.startupEditor') === 'newUntitledFile') {
+            if (editorGroupService.mainPart.hasRestorableState) {
+                return [];
+            }
+            const hasBackups = await workingCopyBackupService.hasBackups();
+            if (hasBackups) {
+                return [];
+            }
+            return [
+                {
+                    editor: { resource: undefined }
+                }
+            ];
+        }
+        return [];
+    }
+    const initialEditorsState = getInitialEditorsState();
+    if (initialEditorsState != null) {
+        logService.info('Initial editor state', initialEditorsState);
+    }
+    let initialLayoutState = {
+        layout: {
+            editors: initialEditorsState?.layout
+        },
+        editor: {
+            restoreEditors: shouldRestoreEditors(contextService, initialEditorsState),
+            editorsToOpen: resolveEditorsToOpen(fileService, initialEditorsState)
+        },
+        views: {
+            defaults: getDefaultLayoutViews(environmentService, storageService),
+            containerToRestore: {}
+        }
+    };
+    function getDefaultViewContainer(location) {
+        return (viewDescriptorService.getDefaultViewContainer(location) ??
+            viewDescriptorService.getViewContainersByLocation(location)[0]);
+    }
+    function initLayoutState() {
+        if (layoutService.isVisible(Parts.SIDEBAR_PART)) {
+            let viewContainerToRestore;
+            if (!environmentService.isBuilt ||
+                lifecycleService.startupKind === StartupKind.ReloadedWindow ||
+                isWeb) {
+                viewContainerToRestore = storageService.get(SidebarPart.activeViewletSettingsKey, StorageScope.WORKSPACE, getDefaultViewContainer(ViewContainerLocation.Sidebar)?.id);
+            }
+            else {
+                viewContainerToRestore = getDefaultViewContainer(ViewContainerLocation.Sidebar)?.id;
+            }
+            initialLayoutState.views.containerToRestore.sideBar = viewContainerToRestore;
+        }
+        if (layoutService.isVisible(Parts.PANEL_PART)) {
+            const viewContainerToRestore = storageService.get(PanelPart.activePanelSettingsKey, StorageScope.WORKSPACE, getDefaultViewContainer(ViewContainerLocation.Panel)?.id);
+            initialLayoutState.views.containerToRestore.panel = viewContainerToRestore;
+        }
+        if (layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
+            const viewContainerToRestore = storageService.get(AuxiliaryBarPart.activePanelSettingsKey, StorageScope.WORKSPACE, getDefaultViewContainer(ViewContainerLocation.AuxiliaryBar)?.id);
+            initialLayoutState.views.containerToRestore.auxiliaryBar = viewContainerToRestore;
+        }
+    }
+    initLayoutState();
+    initialLayoutState = transformInitializationState(initialLayoutState);
+    if (initialLayoutState.views.containerToRestore.sideBar == null) {
+        layoutService.setPartHidden(true, Parts.SIDEBAR_PART);
+    }
+    if (initialLayoutState.views.containerToRestore.panel == null) {
+        layoutService.setPartHidden(true, Parts.PANEL_PART);
+    }
+    if (initialLayoutState.views.containerToRestore.auxiliaryBar == null) {
+        layoutService.setPartHidden(true, Parts.AUXILIARYBAR_PART);
+    }
+    const invisibleContainer = document.createElement('div');
+    invisibleContainer.style.display = 'none';
+    document.body.append(invisibleContainer);
+    for (const { id, role, classes, options, getPosition, onDidChangePosition } of [
+        { id: Parts.TITLEBAR_PART, role: 'none', classes: ['titlebar'] },
+        { id: Parts.BANNER_PART, role: 'banner', classes: ['banner'] },
+        {
+            id: Parts.ACTIVITYBAR_PART,
+            role: 'none',
+            classes: ['activitybar'],
+            getPosition: () => layoutService.getSideBarPosition(),
+            onDidChangePosition: layoutService.onDidChangeSideBarPosition
+        },
+        {
+            id: Parts.SIDEBAR_PART,
+            role: 'none',
+            classes: ['sidebar'],
+            getPosition: () => layoutService.getSideBarPosition(),
+            onDidChangePosition: layoutService.onDidChangeSideBarPosition
+        },
+        {
+            id: Parts.EDITOR_PART,
+            role: 'main',
+            classes: ['editor'],
+            options: { restorePreviousState: initialLayoutState.editor.restoreEditors }
+        },
+        {
+            id: Parts.PANEL_PART,
+            role: 'none',
+            classes: ['panel', 'basepanel'],
+            getPosition: () => layoutService.getPanelPosition(),
+            onDidChangePosition: layoutService.onDidChangePanelPosition
+        },
+        {
+            id: Parts.AUXILIARYBAR_PART,
+            role: 'none',
+            classes: ['auxiliarybar', 'basepanel'],
+            getPosition: () => layoutService.getSideBarPosition() === Position.LEFT ? Position.RIGHT : Position.LEFT,
+            onDidChangePosition: layoutService.onDidChangeSideBarPosition
+        },
+        { id: Parts.STATUSBAR_PART, role: 'status', classes: ['statusbar'] }
+    ]) {
+        const part = layoutService.getPart(id);
+        if (part != null) {
+            const partContainer = createPart(id, role, classes);
+            part.create(partContainer, options);
+            renderPart(partContainer, part);
+            part.layout(9999, 9999, 0, 0);
+            invisibleContainer.append(partContainer);
+            if (getPosition != null) {
+                let position = getPosition();
+                part.element.classList.add(positionToString(position));
+                onDidChangePosition?.(() => {
+                    part.element.classList.remove(positionToString(position));
+                    position = getPosition();
+                    part.element.classList.add(positionToString(position));
+                });
+            }
+        }
+    }
+    const layoutReadyPromises = [];
+    const layoutRestoredPromises = [];
+    layoutReadyPromises.push((async () => {
+        mark('code/willRestoreEditors');
+        await editorGroupService.mainPart.whenReady;
+        mark('code/restoreEditors/editorGroupsReady');
+        if (initialLayoutState.layout?.editors != null) {
+            editorGroupService.applyLayout(initialLayoutState.layout.editors);
+        }
+        const editors = await initialLayoutState.editor.editorsToOpen;
+        mark('code/restoreEditors/editorsToOpenResolved');
+        let openEditorsPromise;
+        if (editors.length > 0) {
+            const editorGroupsInVisualOrder = editorGroupService.getGroups(GroupsOrder.GRID_APPEARANCE);
+            const mapEditorsToGroup = new Map();
+            for (const editor of editors) {
+                const group = editorGroupsInVisualOrder[(editor.viewColumn ?? 1) - 1];
+                let editorsByGroup = mapEditorsToGroup.get(group.id);
+                if (editorsByGroup == null) {
+                    editorsByGroup = new Set();
+                    mapEditorsToGroup.set(group.id, editorsByGroup);
+                }
+                editorsByGroup.add(editor.editor);
+            }
+            openEditorsPromise = Promise.all(Array.from(mapEditorsToGroup).map(async ([groupId, editors]) => {
+                try {
+                    await editorService.openEditors(Array.from(editors), groupId, { validateTrust: true });
+                }
+                catch (error) {
+                    logService.error(error);
+                }
+            }));
+        }
+        layoutRestoredPromises.push(Promise.all([
+            openEditorsPromise?.finally(() => mark('code/restoreEditors/editorsOpened')),
+            editorGroupService.mainPart.whenRestored.finally(() => mark('code/restoreEditors/editorGroupsRestored'))
+        ]).finally(() => {
+            mark('code/didRestoreEditors');
+        }));
+    })());
+    const restoreDefaultViewsPromise = (async () => {
+        if (initialLayoutState.views.defaults != null && initialLayoutState.views.defaults.length > 0) {
+            mark('code/willOpenDefaultViews');
+            const locationsRestored = [];
+            const tryOpenView = (view) => {
+                const location = viewDescriptorService.getViewLocationById(view.id);
+                if (location !== null) {
+                    const container = viewDescriptorService.getViewContainerByViewId(view.id);
+                    if (container != null) {
+                        if (view.order >= (locationsRestored[location]?.order ?? 0)) {
+                            locationsRestored[location] = { id: container.id, order: view.order };
+                        }
+                        const containerModel = viewDescriptorService.getViewContainerModel(container);
+                        containerModel.setCollapsed(view.id, false);
+                        containerModel.setVisible(view.id, true);
+                        return true;
+                    }
+                }
+                return false;
+            };
+            const defaultViews = [...initialLayoutState.views.defaults]
+                .reverse()
+                .map((v, index) => ({ id: v, order: index }));
+            let i = defaultViews.length;
+            while (i > 0) {
+                i--;
+                if (tryOpenView(defaultViews[i])) {
+                    defaultViews.splice(i, 1);
+                }
+            }
+            if (defaultViews.length > 0) {
+                await extensionService.whenInstalledExtensionsRegistered();
+                let i = defaultViews.length;
+                while (i > 0) {
+                    i--;
+                    if (tryOpenView(defaultViews[i])) {
+                        defaultViews.splice(i, 1);
+                    }
+                }
+            }
+            if (locationsRestored[ViewContainerLocation.Sidebar] != null) {
+                initialLayoutState.views.containerToRestore.sideBar =
+                    locationsRestored[ViewContainerLocation.Sidebar].id;
+            }
+            if (locationsRestored[ViewContainerLocation.Panel] != null) {
+                initialLayoutState.views.containerToRestore.panel =
+                    locationsRestored[ViewContainerLocation.Panel].id;
+            }
+            if (locationsRestored[ViewContainerLocation.AuxiliaryBar] != null) {
+                initialLayoutState.views.containerToRestore.auxiliaryBar =
+                    locationsRestored[ViewContainerLocation.AuxiliaryBar].id;
+            }
+            mark('code/didOpenDefaultViews');
+        }
+    })();
+    layoutReadyPromises.push(restoreDefaultViewsPromise);
+    layoutReadyPromises.push((async () => {
+        await restoreDefaultViewsPromise;
+        if (initialLayoutState.views.containerToRestore.sideBar == null) {
+            return;
+        }
+        mark('code/willRestoreViewlet');
+        const viewlet = await paneCompositePartService.openPaneComposite(initialLayoutState.views.containerToRestore.sideBar, ViewContainerLocation.Sidebar);
+        if (viewlet == null) {
+            await paneCompositePartService.openPaneComposite(getDefaultViewContainer(ViewContainerLocation.Sidebar)?.id, ViewContainerLocation.Sidebar);
+        }
+        mark('code/didRestoreViewlet');
+    })());
+    layoutReadyPromises.push((async () => {
+        await restoreDefaultViewsPromise;
+        if (initialLayoutState.views.containerToRestore.panel == null) {
+            return;
+        }
+        mark('code/willRestorePanel');
+        const panel = await paneCompositePartService.openPaneComposite(initialLayoutState.views.containerToRestore.panel, ViewContainerLocation.Panel);
+        if (panel == null) {
+            await paneCompositePartService.openPaneComposite(getDefaultViewContainer(ViewContainerLocation.Panel)?.id, ViewContainerLocation.Panel);
+        }
+        mark('code/didRestorePanel');
+    })());
+    layoutReadyPromises.push((async () => {
+        await restoreDefaultViewsPromise;
+        if (initialLayoutState.views.containerToRestore.auxiliaryBar == null) {
+            return;
+        }
+        mark('code/willRestoreAuxiliaryBar');
+        const panel = await paneCompositePartService.openPaneComposite(initialLayoutState.views.containerToRestore.auxiliaryBar, ViewContainerLocation.AuxiliaryBar);
+        if (panel == null) {
+            await paneCompositePartService.openPaneComposite(getDefaultViewContainer(ViewContainerLocation.AuxiliaryBar)?.id, ViewContainerLocation.AuxiliaryBar);
+        }
+        mark('code/didRestoreAuxiliaryBar');
+    })());
+    await Promises.settled(layoutReadyPromises);
+    await Promises.settled(layoutRestoredPromises);
+});
+function getServiceOverride(openEditorFallback, _webviewIframeAlternateDomains, initializationStateOrRestoreEditors) {
+    if (initializationStateOrRestoreEditors != null) {
+        transformInitializationState =
+            typeof initializationStateOrRestoreEditors === 'boolean'
+                ? (state) => ({
+                    ...state,
+                    editor: {
+                        ...state.editor,
+                        restoreEditors: initializationStateOrRestoreEditors
+                    }
+                })
+                : initializationStateOrRestoreEditors;
+    }
+    return {
+        ...getServiceOverride$1(_webviewIframeAlternateDomains),
+        ...getServiceOverride$2({
+            isKeybindingConfigurationVisible: isEditorPartVisible,
+            shouldUseGlobalPicker: isEditorPartVisible
+        }),
+        ...getServiceOverride$3({
+            shouldUseGlobalKeybindings: isEditorPartVisible
+        }),
+        [IEditorGroupsService.toString()]: new SyncDescriptor(MonacoEditorParts, [], false),
+        [IEditorService.toString()]: new SyncDescriptor(MonacoEditorService, [openEditorFallback, isEditorPartVisible], false)
+    };
+}
+
+export { attachPart, getServiceOverride as default, isEditorPartVisible, onPartVisibilityChange, renderActivitybarPar, renderAuxiliaryPart, renderEditorPart, renderPanelPart, renderPart, renderSidebarPart, renderStatusBarPart };