@codingame/monaco-vscode-api 37.3.11 → 37.5.0

package/vscode/src/vs/workbench/api/common/extHostLogService.js

@@ -8,7 +8,7 @@ import { IExtHostInitDataService } from './extHostInitDataService.js';
 let ExtHostLogService = class ExtHostLogService extends LogService {
     constructor(isWorker, loggerService, initData) {
         const id = initData.remote.isRemote ? "remoteexthost" : isWorker ? "workerexthost" : "exthost";
-        const name = initData.remote.isRemote ? ( localize(5279, "Extension Host (Remote)")) : isWorker ? ( localize(5280, "Extension Host (Worker)")) : ( localize(5281, "Extension Host"));
+        const name = initData.remote.isRemote ? ( localize(5280, "Extension Host (Remote)")) : isWorker ? ( localize(5281, "Extension Host (Worker)")) : ( localize(5282, "Extension Host"));
         super(loggerService.createLogger(id, {
             name
         }));

package/vscode/src/vs/workbench/api/common/extHostNotebook.js

@@ -276,7 +276,7 @@ class ExtHostNotebookController {
                 ));
             }
             if (!this._extHostFileSystem.value.isWritableFileSystem(uri.scheme)) {
-                throw new FileOperationError(( localize(5282, "Unable to modify read-only file '{0}'", this._resourceForError(uri))), FileOperationResult.FILE_PERMISSION_DENIED);
+                throw new FileOperationError(( localize(5283, "Unable to modify read-only file '{0}'", this._resourceForError(uri))), FileOperationResult.FILE_PERMISSION_DENIED);
             }
             const data = {
                 metadata: filter(
@@ -474,7 +474,7 @@ class ExtHostNotebookController {
             mtime: options.mtime ,
             size: stat.size
         })) {
-            throw new FileOperationError(( localize(5283, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
+            throw new FileOperationError(( localize(5284, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
         }
         return;
     }

package/vscode/src/vs/workbench/api/common/extHostStatusBar.js

@@ -195,7 +195,7 @@ class ExtHostStatusBarEntry {
                 name = this._name;
             } else {
                 name = ( localize(
-                    5284,
+                    5285,
                     "{0} (Extension)",
                     this._extension.displayName || this._extension.name
                 ));
@@ -248,7 +248,7 @@ class StatusBarMessage {
             StatusBarAlignment.Left,
             Number.MIN_VALUE
         );
-        this._item.name = ( localize(5285, "Extension Status"));
+        this._item.name = ( localize(5286, "Extension Status"));
     }
     dispose() {
         this._messages.length = 0;

package/vscode/src/vs/workbench/api/common/extHostTelemetry.js

@@ -30,7 +30,7 @@ let ExtHostTelemetry = class ExtHostTelemetry extends Disposable {
         const id = initData.remote.isRemote ? "remoteExtHostTelemetry" : isWorker ? "workerExtHostTelemetry" : "extHostTelemetry";
         this._outputLogger = this._register(loggerService.createLogger(id, {
             name: ( localize(
-                5286,
+                5287,
                 "Extension Telemetry{0}",
                 this._inLoggingOnlyMode ? " (Not Sent)" : ""
             )),

package/vscode/src/vs/workbench/api/common/extHostTerminalService.js

@@ -561,7 +561,7 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
         const terminal = this.getTerminalById(id);
         if (!terminal) {
             return {
-                message: ( localize(5287, "Could not find the terminal with id {0} on the extension host", id))
+                message: ( localize(5288, "Could not find the terminal with id {0} on the extension host", id))
             };
         }
         if (!terminal.isOpen) {

package/vscode/src/vs/workbench/api/common/extHostTunnelService.js

@@ -164,11 +164,11 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
                 if (provider.tunnelFeatures?.public && (privacyOptions.length === 0)) {
                     privacyOptions = [{
                         id: "private",
-                        label: ( localize(5288, "Private")),
+                        label: ( localize(5289, "Private")),
                         themeIcon: "lock"
                     }, {
                         id: "public",
-                        label: ( localize(5289, "Public")),
+                        label: ( localize(5290, "Public")),
                         themeIcon: "eye"
                     }];
                 }

package/vscode/src/vs/workbench/api/common/extHostWorkspace.js

@@ -344,7 +344,7 @@ let ExtHostWorkspace = class ExtHostWorkspace {
                     }
                 };
                 this._messageService.$showMessage(Severity$1.Error, ( localize(
-                    5290,
+                    5291,
                     "Extension '{0}' failed to update workspace folders: {1}",
                     extName,
                     (error.toString())

package/vscode/src/vs/workbench/api/common/jsonValidationExtensionPoint.js

@@ -16,7 +16,7 @@ const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "jsonValidation",
     defaultExtensionKind: ["workspace", "web"],
     jsonSchema: {
-        description: ( localize(5291, "Contributes json schema configuration.")),
+        description: ( localize(5292, "Contributes json schema configuration.")),
         type: "array",
         defaultSnippets: [{
             body: [{
@@ -36,7 +36,7 @@ const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
                 fileMatch: {
                     type: ["string", "array"],
                     description: ( localize(
-                        5292,
+                        5293,
                         "The file pattern (or an array of patterns) to match, for example \"package.json\" or \"*.launch\". Exclusion patterns start with '!'"
                     )),
                     items: {
@@ -45,7 +45,7 @@ const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 url: {
                     description: ( localize(
-                        5293,
+                        5294,
                         "A schema URL ('http:', 'https:') or relative path to the extension folder ('./')."
                     )),
                     type: "string"
@@ -59,7 +59,7 @@ const registryExtPoint = ExtensionsRegistry.registerExtensionPoint({
     defaultExtensionKind: ["workspace", "web"],
     jsonSchema: {
         description: ( localize(
-            5294,
+            5295,
             "Contributes a JSON validation registry. The registry can be a dynamic resource from a filesystem provider and allows associations to change at runtime."
         )),
         type: "array",
@@ -77,7 +77,7 @@ const registryExtPoint = ExtensionsRegistry.registerExtensionPoint({
             }],
             properties: {
                 url: {
-                    description: ( localize(5295, "A registry URI or relative path to the extension folder ('./').")),
+                    description: ( localize(5296, "A registry URI or relative path to the extension folder ('./').")),
                     type: "string"
                 }
             }
@@ -92,20 +92,20 @@ class JSONValidationExtensionPoint {
                 const collector = extension.collector;
                 const extensionLocation = extension.description.extensionLocation;
                 if (!extensionValue || !Array.isArray(extensionValue)) {
-                    collector.error(( localize(5296, "'configuration.jsonValidation' must be a array")));
+                    collector.error(( localize(5297, "'configuration.jsonValidation' must be a array")));
                     return;
                 }
                 extensionValue.forEach(extension => {
                     if (!isString(extension.fileMatch) && !(Array.isArray(extension.fileMatch) && extension.fileMatch.every(isString))) {
                         collector.error(( localize(
-                            5297,
+                            5298,
                             "'configuration.jsonValidation.fileMatch' must be defined as a string or an array of strings."
                         )));
                         return;
                     }
                     const uri = extension.url;
                     if (!isString(uri)) {
-                        collector.error(( localize(5298, "'configuration.jsonValidation.url' must be a URL or relative path")));
+                        collector.error(( localize(5299, "'configuration.jsonValidation.url' must be a URL or relative path")));
                         return;
                     }
                     if (uri.startsWith("./")) {
@@ -113,7 +113,7 @@ class JSONValidationExtensionPoint {
                             const colorThemeLocation = joinPath(extensionLocation, uri);
                             if (!isEqualOrParent(colorThemeLocation, extensionLocation)) {
                                 collector.warn(( localize(
-                                    5299,
+                                    5300,
                                     "Expected `contributes.{0}.url` ({1}) to be included inside extension's folder ({2}). This might make the extension non-portable.",
                                     configurationExtPoint.name,
                                     (colorThemeLocation.toString()),
@@ -122,14 +122,14 @@ class JSONValidationExtensionPoint {
                             }
                         } catch (e) {
                             collector.error(( localize(
-                                5300,
+                                5301,
                                 "'configuration.jsonValidation.url' is an invalid relative URL: {0}",
                                 e.message
                             )));
                         }
                     } else if (!/^[^:/?#]+:\/\//.test(uri)) {
                         collector.error(( localize(
-                            5301,
+                            5302,
                             "'configuration.jsonValidation.url' must be an absolute URL or start with './'  to reference schemas located in the extension."
                         )));
                         return;
@@ -143,14 +143,14 @@ class JSONValidationExtensionPoint {
                 const collector = extension.collector;
                 const extensionLocation = extension.description.extensionLocation;
                 if (!Array.isArray(catalogs)) {
-                    collector.error(( localize(5302, "'configuration.jsonValidationRegistry' must be an array")));
+                    collector.error(( localize(5303, "'configuration.jsonValidationRegistry' must be an array")));
                     continue;
                 }
                 for (const catalog of catalogs) {
                     const uri = catalog?.url;
                     if (!isString(uri)) {
                         collector.error(( localize(
-                            5303,
+                            5304,
                             "'configuration.jsonValidationRegistry.url' must be a URI or relative path"
                         )));
                         continue;
@@ -160,7 +160,7 @@ class JSONValidationExtensionPoint {
                             const catalogLocation = joinPath(extensionLocation, uri);
                             if (!isEqualOrParent(catalogLocation, extensionLocation)) {
                                 collector.warn(( localize(
-                                    5304,
+                                    5305,
                                     "Expected `contributes.{0}.url` ({1}) to be included inside extension's folder ({2}). This might make the extension non-portable.",
                                     registryExtPoint.name,
                                     (catalogLocation.toString()),
@@ -169,14 +169,14 @@ class JSONValidationExtensionPoint {
                             }
                         } catch (e) {
                             collector.error(( localize(
-                                5305,
+                                5306,
                                 "'configuration.jsonValidationRegistry.url' is an invalid relative URI: {0}",
                                 e.message
                             )));
                         }
                     } else if (!/^[^:/?#]+:\/\//.test(uri)) {
                         collector.error(( localize(
-                            5306,
+                            5307,
                             "'configuration.jsonValidationRegistry.url' must be an absolute URI or start with './' to reference a registry located in the extension."
                         )));
                     }
@@ -204,7 +204,7 @@ class JSONValidationDataRenderer extends Disposable {
                 dispose: () => {}
             };
         }
-        const headers = [( localize(5307, "File Match")), ( localize(5308, "Schema"))];
+        const headers = [( localize(5308, "File Match")), ( localize(5309, "Schema"))];
         const rows = contrib.map(v => {
             return [( new MarkdownString()).appendMarkdown(`\`${Array.isArray(v.fileMatch) ? v.fileMatch.join(", ") : v.fileMatch}\``), v.url];
         });
@@ -219,7 +219,7 @@ class JSONValidationDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: "jsonValidation",
-    label: ( localize(5309, "JSON Validation")),
+    label: ( localize(5310, "JSON Validation")),
     access: {
         canToggle: false
     },

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

@@ -0,0 +1,146 @@
+import { IDimension } from "../../base/browser/dom.js";
+import { Direction, IViewSize } from "../../base/browser/ui/grid/grid.js";
+import { Event } from "../../base/common/event.js";
+import { Disposable, DisposableStore, IDisposable } from "../../base/common/lifecycle.js";
+import { ServicesAccessor } from "../../platform/instantiation/common/instantiation.js";
+import { ILayoutOffsetInfo } from "../../platform/layout/browser/layoutService.js";
+import { IPath } from "../../platform/window/common/window.js";
+import { IUntypedEditorInput } from "../common/editor.js";
+import { EditorGroupLayout } from "../services/editor/common/editorGroupsService.js";
+import { IPartVisibilityChangeEvent, MULTI_WINDOW_PARTS, PanelAlignment, Parts, Position, SINGLE_WINDOW_PARTS } from "../services/layout/browser/layoutService.js";
+import { IWorkbenchLayoutService } from "../services/layout/browser/layoutService.service.js";
+import { Part } from "./part.js";
+export declare enum WorkbenchLayoutSettings {
+    AUXILIARYBAR_DEFAULT_VISIBILITY = "workbench.secondarySideBar.defaultVisibility",
+    AUXILIARYBAR_FORCE_MAXIMIZED = "workbench.secondarySideBar.forceMaximized",
+    ACTIVITY_BAR_VISIBLE = "workbench.activityBar.visible",
+    PANEL_POSITION = "workbench.panel.defaultLocation",
+    PANEL_OPENS_MAXIMIZED = "workbench.panel.opensMaximized",
+    ZEN_MODE_CONFIG = "zenMode",
+    EDITOR_CENTERED_LAYOUT_AUTO_RESIZE = "workbench.editor.centeredLayoutAutoResize",
+    EDITOR_RESTORE_EDITORS = "workbench.editor.restoreEditors"
+}
+export interface IEditorToOpen {
+    readonly editor: IUntypedEditorInput;
+    readonly viewColumn?: number;
+}
+export 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 interface IPathToOpen extends IPath {
+    readonly viewColumn?: number;
+}
+export interface IInitialEditorsState {
+    readonly filesToOpenOrCreate?: IPathToOpen[];
+    readonly filesToDiff?: IPathToOpen[];
+    readonly filesToMerge?: IPathToOpen[];
+    readonly layout?: EditorGroupLayout;
+}
+export declare abstract class AbstractLayout extends Disposable implements IWorkbenchLayoutService {
+    protected readonly layoutOptions?: {
+        resetLayout?: boolean;
+        customEditorRestore?: (accessor: ServicesAccessor, defaultLayout: boolean) => Promise<void>;
+    } | undefined;
+    readonly _serviceBrand: undefined;
+    abstract onDidChangeZenMode: Event<boolean>;
+    abstract onDidChangeWindowMaximized: Event<{
+        readonly windowId: number;
+        readonly maximized: boolean;
+    }>;
+    abstract onDidChangeMainEditorCenteredLayout: Event<boolean>;
+    abstract onDidChangePanelPosition: Event<string>;
+    abstract onDidChangePanelAlignment: Event<PanelAlignment>;
+    abstract onDidChangePartVisibility: Event<IPartVisibilityChangeEvent>;
+    abstract onDidChangeNotificationsVisibility: Event<boolean>;
+    abstract onDidChangeAuxiliaryBarMaximized: Event<void>;
+    abstract layout(): void;
+    abstract isRestored(): boolean;
+    abstract whenRestored: Promise<void>;
+    abstract hasFocus(part: Parts): boolean;
+    abstract isFloatingPanelsEnabled(): boolean;
+    abstract isModernUICompact(): boolean;
+    abstract focusPart(part: SINGLE_WINDOW_PARTS): void;
+    abstract focusPart(part: MULTI_WINDOW_PARTS, targetWindow: Window): void;
+    abstract focusPart(part: Parts, targetWindow: Window): void;
+    abstract focusPart(part: unknown, targetWindow?: unknown): void;
+    abstract getContainer(targetWindow: Window): HTMLElement;
+    abstract getContainer(targetWindow: Window, part: Parts): HTMLElement | undefined;
+    abstract getContainer(targetWindow: unknown, part?: unknown): HTMLElement | undefined;
+    abstract isVisible(part: SINGLE_WINDOW_PARTS): boolean;
+    abstract isVisible(part: MULTI_WINDOW_PARTS, targetWindow: Window): boolean;
+    abstract isVisible(part: Parts, targetWindow: Window): boolean;
+    abstract isVisible(part: unknown, targetWindow?: unknown): boolean;
+    abstract setPartHidden(hidden: boolean, part: Parts): void;
+    abstract isSecondarySideBarVisible(): boolean;
+    abstract toggleSecondarySideBar(): void;
+    abstract toggleMaximizedPanel(): void;
+    abstract isPanelMaximized(): boolean;
+    abstract toggleMaximizedAuxiliaryBar(): void;
+    abstract setAuxiliaryBarMaximized(maximized: boolean): boolean;
+    abstract isAuxiliaryBarMaximized(): boolean;
+    abstract hasMainWindowBorder(): boolean;
+    abstract getMainWindowBorderRadius(): string | undefined;
+    abstract getSideBarPosition(): Position;
+    abstract toggleMenuBar(): void;
+    abstract getPanelPosition(): Position;
+    abstract setPanelPosition(position: Position): void;
+    abstract getPanelAlignment(): PanelAlignment;
+    abstract setPanelAlignment(alignment: PanelAlignment): void;
+    abstract getMaximumEditorDimensions(container: HTMLElement): IDimension;
+    abstract toggleZenMode(): void;
+    abstract isMainEditorLayoutCentered(): boolean;
+    abstract centerMainEditorLayout(active: boolean): void;
+    abstract getSize(part: Parts): IViewSize;
+    abstract setSize(part: Parts, size: IViewSize): void;
+    abstract resizePart(part: Parts, sizeChangeWidth: number, sizeChangeHeight: number): void;
+    abstract registerPart(part: Part): IDisposable;
+    abstract isWindowMaximized(targetWindow: Window): boolean;
+    abstract updateWindowMaximizedState(targetWindow: Window, maximized: boolean): void;
+    abstract getVisibleNeighborPart(part: Parts, direction: Direction): Parts | undefined;
+    abstract onDidLayoutMainContainer: Event<IDimension>;
+    abstract onDidLayoutContainer: Event<{
+        readonly container: HTMLElement;
+        readonly dimension: IDimension;
+    }>;
+    abstract onDidLayoutActiveContainer: Event<IDimension>;
+    abstract onDidAddContainer: Event<{
+        readonly container: HTMLElement;
+        readonly disposables: DisposableStore;
+    }>;
+    abstract onDidChangeActiveContainer: Event<void>;
+    abstract mainContainerDimension: IDimension;
+    abstract activeContainerDimension: IDimension;
+    abstract mainContainer: HTMLElement;
+    abstract activeContainer: HTMLElement;
+    abstract containers: Iterable<HTMLElement>;
+    abstract whenContainerStylesLoaded(window: Window): Promise<void> | undefined;
+    abstract mainContainerOffset: ILayoutOffsetInfo;
+    abstract activeContainerOffset: ILayoutOffsetInfo;
+    abstract focus(): void;
+    private _openedDefaultEditors;
+    get openedDefaultEditors(): boolean;
+    constructor(layoutOptions?: {
+        resetLayout?: boolean;
+        customEditorRestore?: (accessor: ServicesAccessor, defaultLayout: boolean) => Promise<void>;
+    } | undefined);
+    protected getInitialEditorsState(accessor: ServicesAccessor): IInitialEditorsState | undefined;
+    protected getInitLayoutState(accessor: ServicesAccessor): ILayoutInitializationState;
+    private getDefaultLayoutViews;
+    private shouldRestoreEditors;
+    private resolveEditorsToOpen;
+    protected restoreLayout(accessor: ServicesAccessor, initialization: ILayoutInitializationState, layoutRestoredPromises: Promise<unknown>[]): Promise<void>;
+}

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

@@ -0,0 +1,247 @@
+
+import { coalesce } from '../../base/common/arrays.js';
+import { Disposable } from '../../base/common/lifecycle.js';
+import { mark } from '../../base/common/performance.js';
+import { URI } from '../../base/common/uri.js';
+import { IConfigurationService } from '../../platform/configuration/common/configuration.service.js';
+import { IFileService } from '../../platform/files/common/files.service.js';
+import { IInstantiationService } from '../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../platform/log/common/log.service.js';
+import { StorageScope } from '../../platform/storage/common/storage.js';
+import { IStorageService } from '../../platform/storage/common/storage.service.js';
+import { isTemporaryWorkspace, WorkbenchState } from '../../platform/workspace/common/workspace.js';
+import { IWorkspaceContextService } from '../../platform/workspace/common/workspace.service.js';
+import { pathsToEditors, isResourceEditorInput } from '../common/editor.js';
+import { GroupsOrder } from '../services/editor/common/editorGroupsService.js';
+import { IEditorGroupsService } from '../services/editor/common/editorGroupsService.service.js';
+import { IEditorService } from '../services/editor/common/editorService.service.js';
+import { IBrowserWorkbenchEnvironmentService } from '../services/environment/browser/environmentService.service.js';
+
+var WorkbenchLayoutSettings;
+(function(WorkbenchLayoutSettings) {
+    WorkbenchLayoutSettings["AUXILIARYBAR_DEFAULT_VISIBILITY"] = "workbench.secondarySideBar.defaultVisibility";
+    WorkbenchLayoutSettings["AUXILIARYBAR_FORCE_MAXIMIZED"] = "workbench.secondarySideBar.forceMaximized";
+    WorkbenchLayoutSettings["ACTIVITY_BAR_VISIBLE"] = "workbench.activityBar.visible";
+    WorkbenchLayoutSettings["PANEL_POSITION"] = "workbench.panel.defaultLocation";
+    WorkbenchLayoutSettings["PANEL_OPENS_MAXIMIZED"] = "workbench.panel.opensMaximized";
+    WorkbenchLayoutSettings["ZEN_MODE_CONFIG"] = "zenMode";
+    WorkbenchLayoutSettings["EDITOR_CENTERED_LAYOUT_AUTO_RESIZE"] = "workbench.editor.centeredLayoutAutoResize";
+    WorkbenchLayoutSettings["EDITOR_RESTORE_EDITORS"] = "workbench.editor.restoreEditors";
+})(WorkbenchLayoutSettings || (WorkbenchLayoutSettings = {}));
+class AbstractLayout extends Disposable {
+    get openedDefaultEditors() {
+        return this._openedDefaultEditors;
+    }
+    constructor(layoutOptions) {
+        super();
+        this.layoutOptions = layoutOptions;
+        this._openedDefaultEditors = false;
+    }
+    getInitialEditorsState(accessor) {
+        const environmentService = accessor.get(IBrowserWorkbenchEnvironmentService);
+        const storageService = accessor.get(IStorageService);
+        const defaultLayout = environmentService.options?.defaultLayout;
+        if ((defaultLayout?.editors?.length || defaultLayout?.layout?.editors) && (defaultLayout.force || storageService.isNew(StorageScope.WORKSPACE))) {
+            this._openedDefaultEditors = true;
+            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 || filesToDiff || filesToMerge) {
+            return {
+                filesToOpenOrCreate,
+                filesToDiff,
+                filesToMerge
+            };
+        }
+        return undefined;
+    }
+    getInitLayoutState(accessor) {
+        const logService = accessor.get(ILogService);
+        const environmentService = accessor.get(IBrowserWorkbenchEnvironmentService);
+        const storageService = accessor.get(IStorageService);
+        const initialEditorsState = this.getInitialEditorsState(accessor);
+        if (initialEditorsState) {
+            logService.trace("Initial editor state", initialEditorsState);
+        }
+        const initialLayoutState = {
+            layout: {
+                editors: initialEditorsState?.layout
+            },
+            editor: {
+                restoreEditors: this.shouldRestoreEditors(accessor, initialEditorsState),
+                editorsToOpen: this.resolveEditorsToOpen(accessor, initialEditorsState)
+            },
+            views: {
+                defaults: this.getDefaultLayoutViews(environmentService, storageService),
+                containerToRestore: {}
+            }
+        };
+        return initialLayoutState;
+    }
+    getDefaultLayoutViews(environmentService, storageService) {
+        const defaultLayout = environmentService.options?.defaultLayout;
+        if (!defaultLayout) {
+            return undefined;
+        }
+        if (!defaultLayout.force && !storageService.isNew(StorageScope.WORKSPACE)) {
+            return undefined;
+        }
+        const {
+            views
+        } = defaultLayout;
+        if (views?.length) {
+            return views.map(view => view.id);
+        }
+        return undefined;
+    }
+    shouldRestoreEditors(accessor, initialEditorsState) {
+        const contextService = accessor.get(IWorkspaceContextService);
+        const configurationService = accessor.get(IConfigurationService);
+        if (isTemporaryWorkspace(contextService.getWorkspace())) {
+            return false;
+        }
+        if (configurationService.getValue(WorkbenchLayoutSettings.EDITOR_RESTORE_EDITORS) === false) {
+            return false;
+        }
+        const forceRestoreEditors = configurationService.getValue("window.restoreWindows") === "preserve";
+        return !!forceRestoreEditors || initialEditorsState === undefined;
+    }
+    async resolveEditorsToOpen(accessor, initialEditorsState) {
+        const fileService = accessor.get(IFileService);
+        const logService = accessor.get(ILogService);
+        const contextService = accessor.get(IWorkspaceContextService);
+        const configurationService = accessor.get(IConfigurationService);
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        if (initialEditorsState) {
+            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) {
+                    filesToOpenOrCreate.push({
+                        editor: resolvedFileToOpenOrCreate,
+                        viewColumn: initialEditorsState.filesToOpenOrCreate?.[i].viewColumn
+                    });
+                }
+            }
+            return filesToOpenOrCreate;
+        }
+        else if (contextService.getWorkbenchState() === WorkbenchState.EMPTY && configurationService.getValue("workbench.startupEditor") === "newUntitledFile") {
+            if (editorGroupService.hasRestorableState) {
+                return [];
+            }
+            return [{
+                editor: {
+                    resource: undefined
+                }
+            }];
+        }
+        return [];
+    }
+    async restoreLayout(accessor, initialization, layoutRestoredPromises) {
+        const instantiationService = accessor.get(IInstantiationService);
+        const editorGroupService = accessor.get(IEditorGroupsService);
+        const editorService = accessor.get(IEditorService);
+        const logService = accessor.get(ILogService);
+        mark("code/willRestoreEditors");
+        await editorGroupService.whenReady;
+        mark("code/restoreEditors/editorGroupsReady");
+        if (initialization.layout?.editors) {
+            editorGroupService.mainPart.applyLayout(initialization.layout.editors);
+        }
+        const editors = await initialization.editor.editorsToOpen;
+        mark("code/restoreEditors/editorsToOpenResolved");
+        let openEditorsPromise = undefined;
+        if (editors.length) {
+            const editorGroupsInVisualOrder = editorGroupService.mainPart.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) {
+                    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);
+                }
+            }));
+        }
+        const customEditorRestorePromise = instantiationService.invokeFunction(
+            this.layoutOptions?.customEditorRestore ?? (async () => {}),
+            !!initialization.layout?.editors
+        );
+        layoutRestoredPromises.push(Promise.all([
+            openEditorsPromise?.finally(() => mark("code/restoreEditors/editorsOpened")),
+            customEditorRestorePromise?.finally(() => mark("code/restoreEditors/customEditorsOpened")),
+            editorGroupService.whenRestored.finally(() => mark("code/restoreEditors/editorGroupsRestored"))
+        ]).finally(() => {
+            mark("code/didRestoreEditors");
+        }));
+    }
+}
+
+export { AbstractLayout, WorkbenchLayoutSettings };