@codingame/monaco-vscode-views-service-override 1.83.12 → 1.83.14

package/index.d.ts

@@ -1,10 +1,11 @@
-export { CustomViewOption, SimpleEditorInput, SimpleEditorPane, attachPart, default, isEditorPartVisible, isPartVisibile, onPartVisibilityChange, registerCustomView, registerEditor, registerEditorPane, registerEditorSerializer, renderActivitybarPar, renderAuxiliaryPart, renderEditorPart, renderPanelPart, renderPart, renderSidebarPart, renderStatusBarPart, setPartVisibility } from './views.js';
+export { CustomViewOption, InitializationStateTransformer, SimpleEditorInput, SimpleEditorPane, attachPart, default, isEditorPartVisible, isPartVisibile, onPartVisibilityChange, registerCustomView, registerEditor, registerEditorPane, registerEditorSerializer, renderActivitybarPar, renderAuxiliaryPart, renderEditorPart, renderPanelPart, renderPart, renderSidebarPart, renderStatusBarPart, setPartVisibility } from './views.js';
 export { SidebarPart } from './vscode/src/vs/workbench/browser/parts/sidebar/sidebarPart.js';
 export { ActivityService } from 'vscode/vscode/vs/workbench/services/activity/browser/activityService';
 export { ActivitybarPart } from './vscode/src/vs/workbench/browser/parts/activitybar/activitybarPart.js';
 export { IReference } from 'vscode/vscode/vs/base/common/lifecycle';
 export { HoverService } from 'vscode/vscode/vs/workbench/services/hover/browser/hoverService';
 export { PanelPart } from './vscode/src/vs/workbench/browser/parts/panel/panelPart.js';
+export { GroupOrientation } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
 export { EditorInputFactoryObject, RegisteredEditorInfo, RegisteredEditorOptions, RegisteredEditorPriority } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
 export { IResolvedTextEditorModel } from 'vscode/vscode/vs/editor/common/services/resolverService';
 export { ConfirmResult } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
@@ -14,6 +15,7 @@ export { EditorInput, IEditorCloseHandler } from 'vscode/vscode/vs/workbench/com
 export { EditorInputCapabilities, IEditorSerializer } from 'vscode/vscode/vs/workbench/common/editor';
 export { EditorPane } from './vscode/src/vs/workbench/browser/parts/editor/editorPane.js';
 export { IEditorOptions } from 'vscode/vscode/vs/platform/editor/common/editor';
+export { ILayoutInitializationState } from './vscode/src/vs/workbench/browser/layout.js';
 export { OpenEditor } from './tools/editor.js';
 export { Parts } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
 export { ViewContainerLocation } from 'vscode/vscode/vs/workbench/common/views';

package/index.js

@@ -1,8 +1,7 @@
 export { SimpleEditorInput, SimpleEditorPane, attachPart, default, isEditorPartVisible, isPartVisibile, onPartVisibilityChange, registerCustomView, registerEditor, registerEditorPane, registerEditorSerializer, renderActivitybarPar, renderAuxiliaryPart, renderEditorPart, renderPanelPart, renderPart, renderSidebarPart, renderStatusBarPart, setPartVisibility } from './views.js';
 export { ViewContainerLocation } from 'vscode/vscode/vs/workbench/common/views';
-export { SidebarPart } from './vscode/src/vs/workbench/browser/parts/sidebar/sidebarPart.js';
 export { ActivitybarPart } from './vscode/src/vs/workbench/browser/parts/activitybar/activitybarPart.js';
-export { PanelPart } from './vscode/src/vs/workbench/browser/parts/panel/panelPart.js';
+export { GroupOrientation } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
 export { RegisteredEditorPriority } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
 export { EditorInputCapabilities } from 'vscode/vscode/vs/workbench/common/editor';
 export { Parts } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
@@ -13,3 +12,5 @@ export { ActivityService } from './vscode/src/vs/workbench/services/activity/bro
 export { EditorInput } from 'vscode/vscode/vs/workbench/common/editor/editorInput';
 export { EditorPane } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorPane';
 export { HoverService } from './vscode/src/vs/workbench/services/hover/browser/hoverService.js';
+export { PanelPart } from './vscode/src/vs/workbench/browser/parts/panel/panelPart.js';
+export { SidebarPart } from './vscode/src/vs/workbench/browser/parts/sidebar/sidebarPart.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-views-service-override",
-  "version": "1.83.12",
+  "version": "1.83.14",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,14 +18,14 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.83.12",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.83.14",
     "monaco-editor": "0.44.0",
-    "@codingame/monaco-vscode-bulk-edit-service-override": "1.83.12",
-    "@codingame/monaco-vscode-layout-service-override": "1.83.12",
-    "@codingame/monaco-vscode-quickaccess-service-override": "1.83.12",
-    "@codingame/monaco-vscode-keybindings-service-override": "1.83.12",
-    "@codingame/monaco-vscode-environment-service-override": "1.83.12",
-    "@codingame/monaco-vscode-extensions-service-override": "1.83.12",
-    "@codingame/monaco-vscode-files-service-override": "1.83.12"
+    "@codingame/monaco-vscode-bulk-edit-service-override": "1.83.14",
+    "@codingame/monaco-vscode-layout-service-override": "1.83.14",
+    "@codingame/monaco-vscode-quickaccess-service-override": "1.83.14",
+    "@codingame/monaco-vscode-keybindings-service-override": "1.83.14",
+    "@codingame/monaco-vscode-environment-service-override": "1.83.14",
+    "@codingame/monaco-vscode-extensions-service-override": "1.83.14",
+    "@codingame/monaco-vscode-files-service-override": "1.83.14"
   }
 }

package/tools/editor.js

@@ -215,10 +215,10 @@ let StandaloneEditorGroup = StandaloneEditorGroup_1 = class StandaloneEditorGrou
         this.closeEditors = unsupported;
         this.closeAllEditors = unsupported;
         this.replaceEditors = unsupported;
-        this.pinEditor = unsupported;
-        this.stickEditor = unsupported;
-        this.unstickEditor = unsupported;
-        this.lock = unsupported;
+        this.pinEditor = () => { };
+        this.stickEditor = () => { };
+        this.unstickEditor = () => { };
+        this.lock = () => { };
         this.isFirst = unsupported;
         this.isLast = unsupported;
         const onNewModel = (uri) => {

package/views.d.ts

@@ -23,6 +23,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/src/vs/workbench/browser/parts/editor/editorPane.js';
+import { ILayoutInitializationState } from './vscode/src/vs/workbench/browser/layout.js';
 import { OpenEditor } from './tools/editor.js';
 
 declare function renderPart(partContainer: HTMLElement, part: Part): void;
@@ -107,6 +108,12 @@ interface CustomViewOption {
 }
 declare function registerCustomView(options: CustomViewOption): IDisposable;
 declare function isEditorPartVisible(): boolean;
-declare function getServiceOverride(openEditorFallback?: OpenEditor, _webviewIframeAlternateDomains?: string, _restoreEditorView?: boolean): IEditorOverrideServices;
+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 { type CustomViewOption, EditorPane, OpenEditor, SimpleEditorInput, SimpleEditorPane, attachPart, getServiceOverride as default, isEditorPartVisible, isPartVisibile, onPartVisibilityChange, registerCustomView, registerEditor, registerEditorPane, registerEditorSerializer, renderActivitybarPar, renderAuxiliaryPart, renderEditorPart, renderPanelPart, renderPart, renderSidebarPart, renderStatusBarPart, setPartVisibility };
+export { type CustomViewOption, EditorPane, ILayoutInitializationState, type InitializationStateTransformer, OpenEditor, SimpleEditorInput, SimpleEditorPane, attachPart, getServiceOverride as default, isEditorPartVisible, isPartVisibile, onPartVisibilityChange, registerCustomView, registerEditor, registerEditorPane, registerEditorSerializer, renderActivitybarPar, renderAuxiliaryPart, renderEditorPart, renderPanelPart, renderPart, renderSidebarPart, renderStatusBarPart, setPartVisibility };

package/views.js

@@ -5,7 +5,7 @@ import { IViewDescriptorService, Extensions, IViewsService } from 'vscode/vscode
 export { ViewContainerLocation } from 'vscode/vscode/vs/workbench/common/views';
 import { ViewsService } from 'vscode/vscode/vs/workbench/browser/parts/views/viewsService';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-export { SidebarPart } from './vscode/src/vs/workbench/browser/parts/sidebar/sidebarPart.js';
+import { SidebarPart } from './vscode/src/vs/workbench/browser/parts/sidebar/sidebarPart.js';
 import { ViewDescriptorService } from './vscode/src/vs/workbench/services/views/browser/viewDescriptorService.js';
 import { IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
 import { ActivityService } from './vscode/src/vs/workbench/services/activity/browser/activityService.js';
@@ -17,7 +17,7 @@ import { IHoverService } from 'vscode/vscode/vs/workbench/services/hover/browser
 import { HoverService } from './vscode/src/vs/workbench/services/hover/browser/hoverService.js';
 import { ExplorerService } from './vscode/src/vs/workbench/contrib/files/browser/explorerService.js';
 import { IExplorerService } from 'vscode/vscode/vs/workbench/contrib/files/browser/files';
-export { PanelPart } from './vscode/src/vs/workbench/browser/parts/panel/panelPart.js';
+import { PanelPart } from './vscode/src/vs/workbench/browser/parts/panel/panelPart.js';
 import { size, $, append } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
@@ -45,6 +45,7 @@ import 'vscode/vscode/vs/workbench/contrib/files/browser/files.contribution';
 import './vscode/src/vs/workbench/contrib/files/browser/files.contribution2.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+export { GroupOrientation } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
 import { IEditorDropService } from 'vscode/vscode/vs/workbench/services/editor/browser/editorDropService';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
 import { IEditorResolverService } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
@@ -56,7 +57,7 @@ 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/vscode/vs/workbench/common/editor/editorInput';
 export { EditorInput } from 'vscode/vscode/vs/workbench/common/editor/editorInput';
-import { EditorExtensions } from 'vscode/vscode/vs/workbench/common/editor';
+import { EditorExtensions, pathsToEditors, isResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor';
 export { EditorInputCapabilities } from 'vscode/vscode/vs/workbench/common/editor';
 import { ITextEditorService, TextEditorService } from 'vscode/vscode/vs/workbench/services/textfile/common/textEditorService';
 import { CodeEditorService } from 'vscode/vscode/vs/workbench/services/editor/browser/codeEditorService';
@@ -85,6 +86,7 @@ import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/commo
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 export { ConfirmResult } from './override/vs/platform/dialogs/common/dialogs.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
 import { IBannerService } from 'vscode/vscode/vs/workbench/services/banner/browser/bannerService';
 import { ITitleService } from 'vscode/vscode/vs/workbench/services/title/common/titleService';
@@ -94,6 +96,18 @@ import { DomScrollableElement } from 'monaco-editor/esm/vs/base/browser/ui/scrol
 import { assertAllDefined, assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
 export { AbstractResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor/resourceEditorInput';
 export { AbstractTextResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor/textResourceEditorInput';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { AuxiliaryBarPart } from './vscode/src/vs/workbench/browser/parts/auxiliarybar/auxiliaryBarPart.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { IWorkspaceContextService, isTemporaryWorkspace } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
 import { MonacoEditorService, MonacoDelegateEditorGroupsService } from './tools/editor.js';
 import getServiceOverride$2 from '@codingame/monaco-vscode-bulk-edit-service-override';
 import getServiceOverride$1 from '@codingame/monaco-vscode-layout-service-override';
@@ -475,14 +489,169 @@ registerAssets({
     'vs/workbench/contrib/webview/browser/pre/index-no-csp.html': () => changeUrlDomain(new URL('./assets/index-no-csp.html', import.meta.url).href, webviewIframeAlternateDomains),
     'vs/workbench/contrib/webview/browser/pre/fake.html': () => changeUrlDomain(new URL('./assets/fake.html', import.meta.url).href, webviewIframeAlternateDomains)
 });
-let restoreEditorView = false;
+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 withStatusBar = accessor.get(IStatusbarService) instanceof Part;
     const withBannerPart = accessor.get(IBannerService) instanceof Part;
     const withTitlePart = accessor.get(ITitleService) instanceof Part;
     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(1 ))) {
+            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(1 )) {
+            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() === 1  && configurationService.getValue('workbench.startupEditor') === 'newUntitledFile') {
+            if (editorGroupService.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("workbench.parts.sidebar" )) {
+            let viewContainerToRestore;
+            if (!environmentService.isBuilt || lifecycleService.startupKind === 3  || isWeb) {
+                viewContainerToRestore = storageService.get(SidebarPart.activeViewletSettingsKey, 1 , getDefaultViewContainer(0 )?.id);
+            }
+            else {
+                viewContainerToRestore = getDefaultViewContainer(0 )?.id;
+            }
+            initialLayoutState.views.containerToRestore.sideBar = viewContainerToRestore;
+        }
+        if (layoutService.isVisible("workbench.parts.panel" )) {
+            const viewContainerToRestore = storageService.get(PanelPart.activePanelSettingsKey, 1 , getDefaultViewContainer(1 )?.id);
+            initialLayoutState.views.containerToRestore.panel = viewContainerToRestore;
+        }
+        if (layoutService.isVisible("workbench.parts.auxiliarybar" )) {
+            const viewContainerToRestore = storageService.get(AuxiliaryBarPart.activePanelSettingsKey, 1 , getDefaultViewContainer(2 )?.id);
+            initialLayoutState.views.containerToRestore.auxiliaryBar = viewContainerToRestore;
+        }
+    }
+    initLayoutState();
+    initialLayoutState = transformInitializationState(initialLayoutState);
+    if (initialLayoutState.views.containerToRestore.sideBar == null) {
+        layoutService.setPartHidden(true, "workbench.parts.sidebar" );
+    }
+    if (initialLayoutState.views.containerToRestore.panel == null) {
+        layoutService.setPartHidden(true, "workbench.parts.panel" );
+    }
+    if (initialLayoutState.views.containerToRestore.auxiliaryBar == null) {
+        layoutService.setPartHidden(true, "workbench.parts.auxiliarybar" );
+    }
     const invisibleContainer = document.createElement('div');
     invisibleContainer.style.display = 'none';
     document.body.append(invisibleContainer);
@@ -491,7 +660,7 @@ onRenderWorkbench(async (accessor) => {
         { id: "workbench.parts.banner" , role: 'banner', classes: ['banner'], enabled: withBannerPart },
         { id: "workbench.parts.activitybar" , role: 'none', classes: ['activitybar', 'left'] },
         { id: "workbench.parts.sidebar" , role: 'none', classes: ['sidebar', 'left'] },
-        { id: "workbench.parts.editor" , role: 'main', classes: ['editor'], options: { restorePreviousState: restoreEditorView } },
+        { id: "workbench.parts.editor" , role: 'main', classes: ['editor'], options: { restorePreviousState: initialLayoutState.editor.restoreEditors } },
         { id: "workbench.parts.panel" , role: 'none', classes: ['panel', 'basepanel', positionToString(2 )] },
         { id: "workbench.parts.auxiliarybar" , role: 'none', classes: ['auxiliarybar', 'basepanel', 'right'] },
         { id: "workbench.parts.statusbar" , role: 'status', classes: ['statusbar'], enabled: withStatusBar }
@@ -503,18 +672,140 @@ onRenderWorkbench(async (accessor) => {
         const part = layoutService.getPart(id);
         part.create(partContainer, options);
         renderPart(partContainer, part);
+        part.layout(9999, 9999, 0, 0);
         invisibleContainer.append(partContainer);
     }
-    await paneCompositePartService.openPaneComposite(viewDescriptorService.getDefaultViewContainer(0 )?.id, 0 );
-    await paneCompositePartService.openPaneComposite(viewDescriptorService.getDefaultViewContainer(1 )?.id, 1 );
-    await paneCompositePartService.openPaneComposite(viewDescriptorService.getDefaultViewContainer(2 )?.id, 2 );
+    const layoutReadyPromises = [];
+    const layoutRestoredPromises = [];
+    layoutReadyPromises.push((async () => {
+        mark('code/willRestoreEditors');
+        await editorGroupService.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(2 );
+            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.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 tryOpenView = (view) => {
+                const location = viewDescriptorService.getViewLocationById(view.id);
+                if (location !== null) {
+                    const container = viewDescriptorService.getViewContainerByViewId(view.id);
+                    if (container != null) {
+                        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);
+                    }
+                }
+            }
+            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, 0 );
+        if (viewlet == null) {
+            await paneCompositePartService.openPaneComposite(getDefaultViewContainer(0 )?.id, 0 );
+        }
+        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, 1 );
+        if (panel == null) {
+            await paneCompositePartService.openPaneComposite(getDefaultViewContainer(1 )?.id, 1 );
+        }
+        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, 2 );
+        if (panel == null) {
+            await paneCompositePartService.openPaneComposite(getDefaultViewContainer(2 )?.id, 2 );
+        }
+        mark('code/didRestoreAuxiliaryBar');
+    })());
+    await Promises.settled(layoutReadyPromises);
+    await Promises.settled(layoutRestoredPromises);
 });
-function getServiceOverride(openEditorFallback, _webviewIframeAlternateDomains, _restoreEditorView) {
+function getServiceOverride(openEditorFallback, _webviewIframeAlternateDomains, initializationStateOrRestoreEditors) {
     if (_webviewIframeAlternateDomains != null) {
         webviewIframeAlternateDomains = _webviewIframeAlternateDomains;
     }
-    if (_restoreEditorView != null) {
-        restoreEditorView = _restoreEditorView;
+    if (initializationStateOrRestoreEditors != null) {
+        transformInitializationState = typeof initializationStateOrRestoreEditors === 'boolean'
+            ? (state) => ({
+                ...state,
+                editor: {
+                    ...state.editor,
+                    restoreEditors: initializationStateOrRestoreEditors
+                }
+            })
+            : initializationStateOrRestoreEditors;
     }
     return {
         ...getServiceOverride$1(),
@@ -551,4 +842,4 @@ function getServiceOverride(openEditorFallback, _webviewIframeAlternateDomains,
     };
 }
 
-export { ActivityService, HoverService, SimpleEditorInput, SimpleEditorPane, attachPart, getServiceOverride as default, isEditorPartVisible, isPartVisibile, onPartVisibilityChange, registerCustomView, registerEditor, registerEditorPane, registerEditorSerializer, renderActivitybarPar, renderAuxiliaryPart, renderEditorPart, renderPanelPart, renderPart, renderSidebarPart, renderStatusBarPart, setPartVisibility };
+export { ActivityService, HoverService, PanelPart, SidebarPart, SimpleEditorInput, SimpleEditorPane, attachPart, getServiceOverride as default, isEditorPartVisible, isPartVisibile, onPartVisibilityChange, registerCustomView, registerEditor, registerEditorPane, registerEditorSerializer, renderActivitybarPar, renderAuxiliaryPart, renderEditorPart, renderPanelPart, renderPart, renderSidebarPart, renderStatusBarPart, setPartVisibility };

package/vscode/src/vs/workbench/browser/layout.d.ts

@@ -0,0 +1,26 @@
+import { IUntypedEditorInput } from 'vscode/vscode/vs/workbench/common/editor';
+import { EditorGroupLayout } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+
+interface IEditorToOpen {
+    readonly editor: IUntypedEditorInput;
+    readonly viewColumn?: number;
+}
+interface ILayoutInitializationState {
+    readonly views: {
+        readonly defaults: string[] | undefined;
+        readonly containerToRestore: {
+            sideBar?: string;
+            panel?: string;
+            auxiliaryBar?: string;
+        };
+    };
+    readonly editor: {
+        readonly restoreEditors: boolean;
+        readonly editorsToOpen: Promise<IEditorToOpen[]>;
+    };
+    readonly layout?: {
+        readonly editors?: EditorGroupLayout;
+    };
+}
+
+export type { IEditorToOpen, ILayoutInitializationState };

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

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { isMacintosh, isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { isMacintosh, isWeb, OS } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
 import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
@@ -8,8 +8,10 @@ import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspac
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { h, append, $, clearNode } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { KeybindingLabel } from 'monaco-editor/esm/vs/base/browser/ui/keybindingLabel/keybindingLabel.js';
 import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { defaultKeybindingLabelStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
 
 const showCommands = { text: ( nls.localizeWithPath(
     'vs/workbench/browser/parts/editor/editorGroupWatermark',
@@ -145,12 +147,28 @@ let EditorGroupWatermark = class EditorGroupWatermark extends Disposable {
         }
         const box = append(this.shortcuts, $('.watermark-box'));
         const folder = this.workbenchState !== 1 ;
-        (folder ? folderEntries : noFolderEntries)
+        const selected = (folder ? folderEntries : noFolderEntries)
             .filter(entry => !('when' in entry) || this.contextKeyService.contextMatchesRules(entry.when))
             .filter(entry => !('mac' in entry) || entry.mac === (isMacintosh && !isWeb))
             .filter(entry => !!CommandsRegistry.getCommand(entry.id));
         const update = () => {
             clearNode(box);
+            selected.forEach(entry => {
+                const keys = this.keybindingService.lookupKeybinding(entry.id);
+                if (!keys) {
+                    return;
+                }
+                const dl = append(box, $('dl'));
+                const dt = append(dl, $('dt'));
+                dt.textContent = entry.text;
+                const dd = append(dl, $('dd'));
+                const keybinding = ( new KeybindingLabel(
+                    dd,
+                    OS,
+                    { renderUnboundKeybindings: true, ...defaultKeybindingLabelStyles }
+                ));
+                keybinding.set(keys);
+            });
         };
         update();
         this.transientDisposables.add(this.keybindingService.onDidUpdateKeybindings(update));