@codingame/monaco-vscode-api 1.83.6 → 1.83.8

package/monaco.d.ts

@@ -18,12 +18,17 @@ export { ContextKeyExpr, RawContextKey } from './vscode/src/vs/platform/contextk
 import { IKeybindingService } from './vscode/src/vs/platform/keybinding/common/keybinding.js';
 import { KeybindingResolver } from './vscode/src/vs/platform/keybinding/common/keybindingResolver.js';
 import { ResolvedKeybindingItem } from './vscode/src/vs/platform/keybinding/common/resolvedKeybindingItem.js';
+import { Event } from './vscode/src/vs/base/common/event.js';
 
 declare function writeFile(uri: URI, content: string): Promise<void>;
 declare function deleteFile(uri: URI, options?: Partial<IFileDeleteOptions>): Promise<void>;
 declare function createModelReference(resource: URI, content?: string): Promise<IReference<ITextFileEditorModel>>;
+interface KeybindingProvider {
+    provideKeybindings(): ResolvedKeybindingItem[];
+    onDidChangeKeybindings: Event<void>;
+}
 interface DynamicKeybindingService extends IKeybindingService {
-    registerKeybindingProvider(provider: () => ResolvedKeybindingItem[]): IDisposable;
+    registerKeybindingProvider(provider: KeybindingProvider): IDisposable;
     _getResolver(): KeybindingResolver;
 }
 declare const createConfiguredEditor: typeof create;
@@ -33,4 +38,4 @@ declare const Extensions: {
     JSONContribution: string;
 };
 
-export { type DynamicKeybindingService, Extensions, IReference, ITextFileEditorModel, createConfiguredDiffEditor, createConfiguredEditor, createModelReference, deleteFile, writeFile };
+export { type DynamicKeybindingService, Extensions, IReference, ITextFileEditorModel, type KeybindingProvider, createConfiguredDiffEditor, createConfiguredEditor, createModelReference, deleteFile, writeFile };

package/monaco.js

@@ -36,6 +36,7 @@ import { INotificationService } from 'monaco-editor/esm/vs/platform/notification
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
 import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { Emitter } from 'monaco-editor';
 import { createInjectedClass } from './tools/injection.js';
 import './vscode/src/vs/workbench/contrib/codeEditor/browser/workbenchReferenceSearch.js';
 import './vscode/src/vs/workbench/contrib/codeEditor/browser/menuPreventer.js';
@@ -144,14 +145,27 @@ let DelegateStandaloneKeybindingService = class DelegateStandaloneKeybindingServ
     constructor(delegate, contextKeyService, commandService, telemetryService, notificationService, logService, codeEditorService) {
         super(contextKeyService, commandService, telemetryService, notificationService, logService, codeEditorService);
         this.delegate = delegate;
-        this._register(delegate.registerKeybindingProvider(() => this.getUserKeybindingItems()));
+        this._onDidChangeKeybindings = new Emitter();
+        this._register(delegate.registerKeybindingProvider({
+            provideKeybindings: () => {
+                return this.getUserKeybindingItems();
+            },
+            onDidChangeKeybindings: this._onDidChangeKeybindings.event
+        }));
     }
     _getResolver() {
         return this.delegate._getResolver();
     }
+    updateResolver() {
+        super.updateResolver();
+        this._onDidChangeKeybindings.fire();
+    }
     resolveKeyboardEvent(keyboardEvent) {
         return this.delegate.resolveKeyboardEvent(keyboardEvent);
     }
+    resolveKeybinding(keybinding) {
+        return this.delegate.resolveKeybinding(keybinding);
+    }
 };
 DelegateStandaloneKeybindingService = __decorate([
     ( __param(1, IContextKeyService)),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.83.6",
+  "version": "1.83.8",
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
   "author": {
@@ -36,6 +36,10 @@
       "types": "./lifecycle.d.ts",
       "default": "./lifecycle.js"
     },
+    "./workbench": {
+      "types": "./workbench.d.ts",
+      "default": "./workbench.js"
+    },
     "./service-override/*": {
       "types": "./service-override/*.d.ts",
       "default": "./service-override/*.js"
@@ -75,6 +79,9 @@
       "lifecycle": [
         "./lifecycle.d.ts"
       ],
+      "workbench": [
+        "./workbench.d.ts"
+      ],
       "l10n": [
         "./l10n.d.ts"
       ],

package/service-override/environment.js

@@ -1,21 +1,21 @@
 import { __decorate, __param } from '../external/tslib/tslib.es6.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { IBrowserWorkbenchEnvironmentService, BrowserWorkbenchEnvironmentService } from '../vscode/src/vs/workbench/services/environment/browser/environmentService.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
 import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { logsPath, getWorkspaceIdentifier, getWorkbenchConstructionOptions } from '../workbench.js';
 let InjectedBrowserWorkbenchEnvironmentService = class InjectedBrowserWorkbenchEnvironmentService extends BrowserWorkbenchEnvironmentService {
-    constructor(options, productService) {
-        super('default', ( URI.from({ scheme: 'logs', path: '/' })), options, productService);
+    constructor(workspaceId = getWorkspaceIdentifier().id, options = getWorkbenchConstructionOptions(), productService) {
+        super(workspaceId, logsPath, options, productService);
     }
 };
 InjectedBrowserWorkbenchEnvironmentService = __decorate([
-    ( __param(1, IProductService))
+    ( __param(2, IProductService))
 ], InjectedBrowserWorkbenchEnvironmentService);
-function getServiceOverride(options = {}) {
+function getServiceOverride(options) {
     return {
         [( IEnvironmentService.toString())]: new SyncDescriptor(InjectedBrowserWorkbenchEnvironmentService, [], true),
-        [( IBrowserWorkbenchEnvironmentService.toString())]: new SyncDescriptor(InjectedBrowserWorkbenchEnvironmentService, [options], true)
+        [( IBrowserWorkbenchEnvironmentService.toString())]: new SyncDescriptor(InjectedBrowserWorkbenchEnvironmentService, [undefined, options], true)
     };
 }
 export { getServiceOverride as default };

package/service-override/files.js

@@ -16,8 +16,11 @@ export { HTMLFileSystemProvider } from 'monaco-editor/esm/vs/platform/files/brow
 import * as path from 'monaco-editor/esm/vs/base/common/path.js';
 import '../vscode/src/vs/workbench/contrib/files/browser/files.contribution.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-export { IndexedDBFileSystemProvider } from '../vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js';
+import { IndexedDBFileSystemProvider } from '../vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js';
+import { IndexedDB } from 'monaco-editor/esm/vs/base/browser/indexedDB.js';
 export { IndexedDB } from 'monaco-editor/esm/vs/base/browser/indexedDB.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { logsPath } from '../workbench.js';
 class RegisteredFile {
     constructor(uri, readonly) {
         this.uri = uri;
@@ -395,13 +398,13 @@ const userDataFileSystemProvider = new InMemoryFileSystemProvider();
 void userDataFileSystemProvider.mkdir(( URI.from({ scheme: Schemas.vscodeUserData, path: '/User/' })));
 const providers = {
     extension: extensionFileSystemProvider,
-    logs: new InMemoryFileSystemProvider(),
+    [logsPath.scheme]: new InMemoryFileSystemProvider(),
     [Schemas.vscodeUserData]: userDataFileSystemProvider,
     [Schemas.tmp]: new InMemoryFileSystemProvider(),
     file: fileSystemProvider
 };
 let MemoryFileService = class MemoryFileService extends FileService {
-    constructor(logService) {
+    constructor(logService, telemetryService) {
         super(logService);
         for (const [scheme, provider] of Object.entries(providers)) {
             let disposable = this.registerProvider(scheme, provider);
@@ -411,11 +414,15 @@ let MemoryFileService = class MemoryFileService extends FileService {
                     disposable = this.registerProvider(scheme, fileSystemProvider);
                 });
             }
+            if (provider instanceof IndexedDBFileSystemProvider) {
+                this._register(provider.onReportError(e => telemetryService.publicLog2('indexedDBFileSystemProviderError', e)));
+            }
         }
     }
 };
 MemoryFileService = __decorate([
-    ( __param(0, ILogService))
+    ( __param(0, ILogService)),
+    ( __param(1, ITelemetryService))
 ], MemoryFileService);
 function getServiceOverride() {
     return {
@@ -433,6 +440,14 @@ async function initFile(scheme, file, content, options) {
     if (provider == null || provider.writeFile == null) {
         throw new Error(`${scheme} provider doesn't exist or doesn't support writing files`);
     }
+    if (!(options?.overwrite ?? false)) {
+        try {
+            await provider.stat(file);
+            return;
+        }
+        catch (error) {
+        }
+    }
     await provider.writeFile(file, content instanceof Uint8Array ? content : encoder.encode(content), {
         atomic: false,
         create: true,
@@ -441,7 +456,16 @@ async function initFile(scheme, file, content, options) {
         ...options
     });
 }
+async function createIndexedDBProviders() {
+    const userDataStore = 'vscode-userdata-store';
+    const logsStore = 'vscode-logs-store';
+    const indexedDB = await IndexedDB.create('vscode-web-db', 3, [userDataStore, logsStore]);
+    providers[logsPath.scheme] = new IndexedDBFileSystemProvider(logsPath.scheme, indexedDB, logsStore, false);
+    const userDataProvider = new IndexedDBFileSystemProvider(Schemas.vscodeUserData, indexedDB, userDataStore, true);
+    providers[Schemas.vscodeUserData] = userDataProvider;
+    return userDataProvider;
+}
 function registerFileSystemOverlay(priority, provider) {
     return fileSystemProvider.register(priority, provider);
 }
-export { DelegateFileSystemProvider, FilePermission, FileType, InMemoryFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, getServiceOverride as default, initFile, registerCustomProvider, registerExtensionFile, registerFileSystemOverlay };
+export { DelegateFileSystemProvider, FilePermission, FileType, InMemoryFileSystemProvider, IndexedDBFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, createIndexedDBProviders, getServiceOverride as default, initFile, registerCustomProvider, registerExtensionFile, registerFileSystemOverlay };

package/service-override/keybindings.js

@@ -10,7 +10,7 @@ import { BrowserKeyboardLayoutService } from '../vscode/src/vs/workbench/service
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { CommandService } from '../vscode/src/vs/workbench/services/commands/common/commandService.js';
-import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
 import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
@@ -23,6 +23,7 @@ import { WorkbenchContextKeysHandler } from '../vscode/src/vs/workbench/browser/
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import getServiceOverride$1, { initFile } from './files.js';
+import '../monaco.js';
 import { onRenderWorkbench } from '../lifecycle.js';
 import '../services.js';
 import '../vscode/src/vs/workbench/browser/workbench.contribution.js';
@@ -45,13 +46,18 @@ let DynamicWorkbenchKeybindingService = class DynamicWorkbenchKeybindingService
     registerKeybindingProvider(provider) {
         this.keybindingProviders.push(provider);
         this.updateResolver();
-        return toDisposable(() => {
+        const store = new DisposableStore();
+        store.add(provider.onDidChangeKeybindings(() => {
+            this.updateResolver();
+        }));
+        store.add(toDisposable(() => {
             const idx = this.keybindingProviders.indexOf(provider);
             if (idx >= 0) {
                 this.keybindingProviders.splice(idx, 1);
                 this.updateResolver();
             }
-        });
+        }));
+        return store;
     }
     _getResolver() {
         return super._getResolver();
@@ -63,7 +69,7 @@ let DynamicWorkbenchKeybindingService = class DynamicWorkbenchKeybindingService
         return super._dispatch(e, target);
     }
     getUserKeybindingItems() {
-        return [...super.getUserKeybindingItems(), ...this.keybindingProviders.flatMap(provider => provider())];
+        return [...super.getUserKeybindingItems(), ...this.keybindingProviders.flatMap(provider => provider.provideKeybindings())];
     }
 };
 DynamicWorkbenchKeybindingService = __decorate([

package/service-override/layout.js

@@ -1,5 +1,4 @@
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
-import { IWorkbenchLayoutService } from '../vscode/src/vs/workbench/services/layout/browser/layoutService.js';
 import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
 import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
@@ -13,8 +12,9 @@ import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { IEditorGroupsService } from '../vscode/src/vs/workbench/services/editor/common/editorGroupsService.js';
 import { IStatusbarService } from '../vscode/src/vs/workbench/services/statusbar/browser/statusbar.js';
 import { onRenderWorkbench } from '../lifecycle.js';
+import { getWorkbenchContainer } from '../workbench.js';
 class LayoutService {
-    constructor(container) {
+    constructor(container = getWorkbenchContainer()) {
         this.container = container;
         this.onDidChangeFullscreen = Event.None;
         this.onDidChangeZenMode = Event.None;
@@ -210,8 +210,6 @@ onRenderWorkbench((accessor) => {
     if (layoutService instanceof LayoutService) {
         layoutService.init(accessor);
     }
-});
-function getServiceOverride(container = document.body) {
     const platformClass = isWindows ? 'windows' : isLinux ? 'linux' : 'mac';
     const workbenchClasses = coalesce([
         'monaco-workbench',
@@ -219,12 +217,13 @@ function getServiceOverride(container = document.body) {
         'web',
         isChrome ? 'chromium' : isFirefox ? 'firefox' : isSafari ? 'safari' : undefined
     ]);
-    container.classList.add(...workbenchClasses);
+    layoutService.container.classList.add(...workbenchClasses);
     document.body.classList.add(platformClass);
     document.body.classList.add('web');
+});
+function getServiceOverride(container) {
     return {
-        [( ILayoutService.toString())]: new SyncDescriptor(LayoutService, [container], true),
-        [( IWorkbenchLayoutService.toString())]: new SyncDescriptor(LayoutService, [container], true)
+        [( ILayoutService.toString())]: new SyncDescriptor(LayoutService, [container], true)
     };
 }
 export { LayoutService, getServiceOverride as default };

package/service-override/output.js

@@ -1,19 +1,21 @@
 import { __decorate, __param } from '../external/tslib/tslib.es6.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { ILoggerService, LogLevel } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { ILoggerService, getLogLevel } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { FileLoggerService } from '../vscode/src/vs/platform/log/common/fileLog.js';
 import '../vscode/src/vs/workbench/contrib/output/browser/output.contribution.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { logsPath } from '../workbench.js';
 let _FileLoggerService = class _FileLoggerService extends FileLoggerService {
-    constructor(logLevel, fileService) {
-        super(logLevel, ( URI.from({ scheme: 'logs', path: '/' })), fileService);
+    constructor(logLevel, fileService, environmentService) {
+        super(logLevel ?? getLogLevel(environmentService), logsPath, fileService);
     }
 };
 _FileLoggerService = __decorate([
-    ( __param(1, IFileService))
+    ( __param(1, IFileService)),
+    ( __param(2, IEnvironmentService))
 ], _FileLoggerService);
-function getServiceOverride(logLevel = LogLevel.Info) {
+function getServiceOverride(logLevel) {
     return {
         [( ILoggerService.toString())]: new SyncDescriptor(_FileLoggerService, [logLevel], true)
     };

package/service-override/tools/editor.d.ts

@@ -8,12 +8,12 @@ import { IWorkspaceContextService } from '../../vscode/src/vs/platform/workspace
 import { IUriIdentityService } from '../../vscode/src/vs/platform/uriIdentity/common/uriIdentity.js';
 import { ICodeEditor, IDiffEditor } from '../../vscode/src/vs/editor/browser/editorBrowser.js';
 import { IEditorOptions, IResourceEditorInput, ITextResourceEditorInput } from '../../vscode/src/vs/platform/editor/common/editor.js';
+import { IHostService } from '../../vscode/src/vs/workbench/services/host/browser/host.js';
 import { IEditorGroupsService } from '../../vscode/src/vs/workbench/services/editor/common/editorGroupsService.js';
 import { EditorInput } from '../../vscode/src/vs/workbench/common/editor/editorInput.js';
 import { PreferredGroup } from '../../vscode/src/vs/workbench/services/editor/common/editorService.js';
 import { IEditorResolverService } from '../../vscode/src/vs/workbench/services/editor/common/editorResolverService.js';
 import { ITextEditorService } from '../../vscode/src/vs/workbench/services/textfile/common/textEditorService.js';
-import { IHostService } from '../../vscode/src/vs/workbench/services/host/browser/host.js';
 import { IWorkspaceTrustRequestService } from '../../vscode/src/vs/platform/workspace/common/workspaceTrust.js';
 import { EditorService } from '../../vscode/src/vs/workbench/services/editor/browser/editorService.js';
 

package/services.d.ts

@@ -9,6 +9,7 @@ import { ServiceIdentifier, GetLeadingNonServiceArgs, ServicesAccessor } from '.
 export { IInstantiationService } from './vscode/src/vs/platform/instantiation/common/instantiation.js';
 export { IAction } from './vscode/src/vs/base/common/actions.js';
 import { IDisposable } from './vscode/src/vs/base/common/lifecycle.js';
+import { IWorkbenchConstructionOptions } from './vscode/src/vs/workbench/browser/web.api.js';
 export { SyncDescriptor } from './vscode/src/vs/platform/instantiation/common/descriptors.js';
 export { ICommandService } from './vscode/src/vs/platform/commands/common/commands.js';
 export { INeverShowAgainOptions, INotification, INotificationActions, INotificationHandle, INotificationProgress, INotificationProgressProperties, INotificationProperties, INotificationService, IPromptChoice, IPromptChoiceWithMenu, IPromptOptions, IStatusMessageOptions, NeverShowAgainScope, NoOpNotification, NoOpProgress, NotificationMessage, NotificationPriority, NotificationsFilter } from './vscode/src/vs/platform/notification/common/notification.js';
@@ -73,7 +74,7 @@ export { ITitleService } from './vscode/src/vs/workbench/services/title/common/t
 export { IBannerService } from './vscode/src/vs/workbench/services/banner/browser/bannerService.js';
 export { IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService, IWorkspaceTrustRequestService, IWorkspaceTrustUriInfo } from './vscode/src/vs/platform/workspace/common/workspaceTrust.js';
 
-declare function initialize(overrides: IEditorOverrideServices, container?: HTMLElement): Promise<void>;
+declare function initialize(overrides: IEditorOverrideServices, container?: HTMLElement, configuration?: IWorkbenchConstructionOptions): Promise<void>;
 declare function waitServicesReady(): Promise<void>;
 declare function checkServicesReady(): void;
 declare function getService<T>(identifier: ServiceIdentifier<T>): Promise<T>;
@@ -84,4 +85,4 @@ declare function createInstanceSync<Ctor extends new (...args: any[]) => any, R
  */
 declare function withReadyServices(callback: (serviceAccessor: ServicesAccessor) => IDisposable): IDisposable;
 
-export { checkServicesReady, createInstance, createInstanceSync, getService, initialize, waitServicesReady, withReadyServices };
+export { IWorkbenchConstructionOptions, checkServicesReady, createInstance, createInstanceSync, getService, initialize, waitServicesReady, withReadyServices };

package/services.js

@@ -12,6 +12,7 @@ import getServiceOverride$2 from './service-override/extensions.js';
 import getServiceOverride$3 from './service-override/files.js';
 import getServiceOverride$4 from './service-override/quickaccess.js';
 import { startup, serviceInitializedBarrier, serviceInitializedEmitter } from './lifecycle.js';
+import { initialize as initialize$1 } from './workbench.js';
 export { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 export { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 export { INotificationService, NeverShowAgainScope, NoOpNotification, NoOpProgress, NotificationPriority, NotificationsFilter } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
@@ -81,12 +82,13 @@ StandaloneServices.withServices(() => {
     servicesInitialized = true;
     return Disposable.None;
 });
-async function initialize(overrides, container) {
+async function initialize(overrides, container = document.body, configuration = {}) {
     if (servicesInitialized) {
         throw new Error('The services are already initialized.');
     }
+    initialize$1(container, configuration);
     const instantiationService = StandaloneServices.initialize({
-        ...getServiceOverride(container),
+        ...getServiceOverride(),
         ...getServiceOverride$1(),
         ...getServiceOverride$2(),
         ...getServiceOverride$3(),

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

@@ -3,10 +3,10 @@ import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { EditorPaneDescriptor } from '../../editor.js';
 import { EditorExtensions } from '../../../common/editor.js';
 import { ActiveEditorGroupLockedContext, MultipleEditorGroupsContext, EditorPinnedAndUnpinnedTabsContext, EditorGroupEditorsCountContext, ActiveEditorLastInGroupContext, EditorTabsVisibleContext, ActiveEditorAvailableEditorIdsContext, ActiveEditorPinnedContext, ActiveEditorStickyContext, ActiveEditorCanSplitInGroupContext, SideBySideEditorActiveContext, TextCompareEditorActiveContext, ActiveEditorDirtyContext } from '../../../common/contextkeys.js';
-import { SideBySideEditorInput } from '../../../common/editor/sideBySideEditorInput.js';
+import { SideBySideEditorInput, SideBySideEditorInputSerializer } from '../../../common/editor/sideBySideEditorInput.js';
 import { TextResourceEditor } from './textResourceEditor.js';
 import { SideBySideEditor } from './sideBySideEditor.js';
-import { DiffEditorInput } from '../../../common/editor/diffEditorInput.js';
+import { DiffEditorInput, DiffEditorInputSerializer } from '../../../common/editor/diffEditorInput.js';
 import { UntitledTextEditorInput } from '../../../services/untitled/common/untitledTextEditorInput.js';
 import { TextResourceEditorInput } from '../../../common/editor/textResourceEditorInput.js';
 import { TextDiffEditor } from './textDiffEditor.js';
@@ -28,7 +28,7 @@ import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/quicki
 import { ActiveGroupEditorsByMostRecentlyUsedQuickAccess, AllEditorsByAppearanceQuickAccess, AllEditorsByMostRecentlyUsedQuickAccess } from './editorQuickAccess.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-import { UntitledTextEditorWorkingCopyEditorHandler } from '../../../services/untitled/common/untitledTextEditorHandler.js';
+import { UntitledTextEditorInputSerializer, UntitledTextEditorWorkingCopyEditorHandler } from '../../../services/untitled/common/untitledTextEditorHandler.js';
 import { DynamicEditorConfigurations } from './editorConfiguration.js';
 import { ToggleTabsVisibilityAction, ToggleSeparatePinnedTabsAction } from '../../actions/layoutActions.js';
 ( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(TextResourceEditor, TextResourceEditor.ID, ( localizeWithPath(
@@ -60,6 +60,9 @@ import { ToggleTabsVisibilityAction, ToggleSeparatePinnedTabsAction } from '../.
 ))), [
     ( new SyncDescriptor(SideBySideEditorInput))
 ]);
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(UntitledTextEditorInput.ID, UntitledTextEditorInputSerializer);
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(SideBySideEditorInput.ID, SideBySideEditorInputSerializer);
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(DiffEditorInput.ID, DiffEditorInputSerializer);
 ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(EditorAutoSave, 2 );
 ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(EditorStatus, 2 );
 ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(UntitledTextEditorWorkingCopyEditorHandler, 2 );

package/vscode/src/vs/workbench/common/editor/diffEditorInput.js

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { SideBySideEditorInput } from './sideBySideEditorInput.js';
+import { SideBySideEditorInput, AbstractSideBySideEditorInputSerializer } from './sideBySideEditorInput.js';
 import { BINARY_DIFF_EDITOR_ID, TEXT_DIFF_EDITOR_ID, isResourceDiffEditorInput } from '../editor.js';
 import { BaseTextEditorModel } from './textEditorModel.js';
 import { DiffEditorModel } from './diffEditorModel.js';
@@ -165,4 +165,9 @@ let DiffEditorInput = class DiffEditorInput extends SideBySideEditorInput {
 DiffEditorInput = DiffEditorInput_1 = ( __decorate([
     ( __param(5, IEditorService))
 ], DiffEditorInput));
-export { DiffEditorInput };
+class DiffEditorInputSerializer extends AbstractSideBySideEditorInputSerializer {
+    createEditorInput(instantiationService, name, description, secondaryInput, primaryInput) {
+        return instantiationService.createInstance(DiffEditorInput, name, description, secondaryInput, primaryInput, undefined);
+    }
+}
+export { DiffEditorInput, DiffEditorInputSerializer };

package/vscode/src/vs/workbench/common/editor/sideBySideEditorInput.js

@@ -1,7 +1,8 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { isResourceDiffEditorInput, isResourceSideBySideEditorInput, isResourceMergeEditorInput, isEditorInput, findViewStateForEditor, isResourceEditorInput, isDiffEditorInput } from '../editor.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { isResourceDiffEditorInput, isResourceSideBySideEditorInput, isResourceMergeEditorInput, isEditorInput, findViewStateForEditor, isResourceEditorInput, isDiffEditorInput, EditorExtensions } from '../editor.js';
 import { EditorInput } from './editorInput.js';
 import { IEditorService } from '../../services/editor/common/editorService.js';
 var SideBySideEditorInput_1;
@@ -231,4 +232,57 @@ let SideBySideEditorInput = class SideBySideEditorInput extends EditorInput {
 SideBySideEditorInput = SideBySideEditorInput_1 = ( __decorate([
     ( __param(4, IEditorService))
 ], SideBySideEditorInput));
-export { SideBySideEditorInput };
+class AbstractSideBySideEditorInputSerializer {
+    canSerialize(editorInput) {
+        const input = editorInput;
+        if (input.primary && input.secondary) {
+            const [secondaryInputSerializer, primaryInputSerializer] = this.getSerializers(input.secondary.typeId, input.primary.typeId);
+            return !!(secondaryInputSerializer?.canSerialize(input.secondary) && primaryInputSerializer?.canSerialize(input.primary));
+        }
+        return false;
+    }
+    serialize(editorInput) {
+        const input = editorInput;
+        if (input.primary && input.secondary) {
+            const [secondaryInputSerializer, primaryInputSerializer] = this.getSerializers(input.secondary.typeId, input.primary.typeId);
+            if (primaryInputSerializer && secondaryInputSerializer) {
+                const primarySerialized = primaryInputSerializer.serialize(input.primary);
+                const secondarySerialized = secondaryInputSerializer.serialize(input.secondary);
+                if (primarySerialized && secondarySerialized) {
+                    const serializedEditorInput = {
+                        name: input.getPreferredName(),
+                        description: input.getPreferredDescription(),
+                        primarySerialized: primarySerialized,
+                        secondarySerialized: secondarySerialized,
+                        primaryTypeId: input.primary.typeId,
+                        secondaryTypeId: input.secondary.typeId
+                    };
+                    return JSON.stringify(serializedEditorInput);
+                }
+            }
+        }
+        return undefined;
+    }
+    deserialize(instantiationService, serializedEditorInput) {
+        const deserialized = JSON.parse(serializedEditorInput);
+        const [secondaryInputSerializer, primaryInputSerializer] = this.getSerializers(deserialized.secondaryTypeId, deserialized.primaryTypeId);
+        if (primaryInputSerializer && secondaryInputSerializer) {
+            const primaryInput = primaryInputSerializer.deserialize(instantiationService, deserialized.primarySerialized);
+            const secondaryInput = secondaryInputSerializer.deserialize(instantiationService, deserialized.secondarySerialized);
+            if (primaryInput instanceof EditorInput && secondaryInput instanceof EditorInput) {
+                return this.createEditorInput(instantiationService, deserialized.name, deserialized.description, secondaryInput, primaryInput);
+            }
+        }
+        return undefined;
+    }
+    getSerializers(secondaryEditorInputTypeId, primaryEditorInputTypeId) {
+        const registry = ( Registry.as(EditorExtensions.EditorFactory));
+        return [registry.getEditorSerializer(secondaryEditorInputTypeId), registry.getEditorSerializer(primaryEditorInputTypeId)];
+    }
+}
+class SideBySideEditorInputSerializer extends AbstractSideBySideEditorInputSerializer {
+    createEditorInput(instantiationService, name, description, secondaryInput, primaryInput) {
+        return instantiationService.createInstance(SideBySideEditorInput, name, description, secondaryInput, primaryInput);
+    }
+}
+export { AbstractSideBySideEditorInputSerializer, SideBySideEditorInput, SideBySideEditorInputSerializer };

package/vscode/src/vs/workbench/common/editor.d.ts

@@ -235,6 +235,22 @@ interface ITextDiffEditorPane extends IEditorPane {
  */
 interface IEditorControl extends ICompositeControl {
 }
+interface IEditorSerializer {
+    /**
+     * Determines whether the given editor can be serialized by the serializer.
+     */
+    canSerialize(editor: EditorInput): boolean;
+    /**
+     * Returns a string representation of the provided editor that contains enough information
+     * to deserialize back to the original editor from the deserialize() method.
+     */
+    serialize(editor: EditorInput): string | undefined;
+    /**
+     * Returns an editor from the provided serialized form of the editor. This form matches
+     * the value returned from the serialize() method.
+     */
+    deserialize(instantiationService: IInstantiationService, serializedEditor: string): EditorInput | undefined;
+}
 interface IUntitledTextResourceEditorInput extends IBaseTextResourceEditorInput {
     /**
      * Optional resource for the untitled editor. Depending on the value, the editor:
@@ -711,4 +727,4 @@ declare const enum EditorsOrder {
     SEQUENTIAL = 1
 }
 
-export { AbstractEditorInput, CloseDirection, EditorCloseContext, EditorInputCapabilities, type EditorInputWithOptions, type EditorInputWithOptionsAndGroup, type EditorInputWithPreferredResource, EditorPaneSelectionChangeReason, EditorPaneSelectionCompareResult, EditorsOrder, type GroupIdentifier, GroupModelChangeKind, type IActiveEditorChangeEvent, type IEditorCloseEvent, type IEditorControl, type IEditorDescriptor, type IEditorIdentifier, type IEditorMemento, type IEditorOpenContext, type IEditorPane, type IEditorPaneSelection, type IEditorPaneSelectionChangeEvent, type IEditorPartOptions, type IEditorPartOptionsChangeEvent, type IEditorWillMoveEvent, type IEditorWillOpenEvent, type IFileEditorInput, type IFindEditorOptions, type IMatchEditorOptions, type IMoveResult, type IResourceDiffEditorInput, type IResourceMergeEditorInput, type IResourceMergeEditorInputSide, type IResourceSideBySideEditorInput, type IRevertOptions, type ISaveOptions, type ITextDiffEditorPane, type IUntitledTextResourceEditorInput, type IUntypedEditorInput, type IUntypedFileEditorInput, type IVisibleEditorPane, type PreventPinnedEditorClose, SaveReason, type SaveSource, SideBySideEditor, Verbosity };
+export { AbstractEditorInput, CloseDirection, EditorCloseContext, EditorInputCapabilities, type EditorInputWithOptions, type EditorInputWithOptionsAndGroup, type EditorInputWithPreferredResource, EditorPaneSelectionChangeReason, EditorPaneSelectionCompareResult, EditorsOrder, type GroupIdentifier, GroupModelChangeKind, type IActiveEditorChangeEvent, type IEditorCloseEvent, type IEditorControl, type IEditorDescriptor, type IEditorIdentifier, type IEditorMemento, type IEditorOpenContext, type IEditorPane, type IEditorPaneSelection, type IEditorPaneSelectionChangeEvent, type IEditorPartOptions, type IEditorPartOptionsChangeEvent, type IEditorSerializer, type IEditorWillMoveEvent, type IEditorWillOpenEvent, type IFileEditorInput, type IFindEditorOptions, type IMatchEditorOptions, type IMoveResult, type IResourceDiffEditorInput, type IResourceMergeEditorInput, type IResourceMergeEditorInputSide, type IResourceSideBySideEditorInput, type IRevertOptions, type ISaveOptions, type ITextDiffEditorPane, type IUntitledTextResourceEditorInput, type IUntypedEditorInput, type IUntypedFileEditorInput, type IVisibleEditorPane, type PreventPinnedEditorClose, SaveReason, type SaveSource, SideBySideEditor, Verbosity };

package/vscode/src/vs/workbench/services/untitled/common/untitledTextEditorHandler.js

@@ -1,14 +1,65 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { ITextEditorService } from '../../textfile/common/textEditorService.js';
-import { isEqual, toLocalResource } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { toLocalResource, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
 import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { IFilesConfigurationService } from '../../filesConfiguration/common/filesConfigurationService.js';
 import { IPathService } from '../../path/common/pathService.js';
 import { UntitledTextEditorInput } from './untitledTextEditorInput.js';
 import { NO_TYPE_ID } from '../../workingCopy/common/workingCopy.js';
 import { IWorkingCopyEditorService } from '../../workingCopy/common/workingCopyEditorService.js';
 import { IUntitledTextEditorService } from './untitledTextEditorService.js';
+let UntitledTextEditorInputSerializer = class UntitledTextEditorInputSerializer {
+    constructor(filesConfigurationService, environmentService, pathService) {
+        this.filesConfigurationService = filesConfigurationService;
+        this.environmentService = environmentService;
+        this.pathService = pathService;
+    }
+    canSerialize(editorInput) {
+        return this.filesConfigurationService.isHotExitEnabled && !editorInput.isDisposed();
+    }
+    serialize(editorInput) {
+        if (!this.filesConfigurationService.isHotExitEnabled || editorInput.isDisposed()) {
+            return undefined;
+        }
+        const untitledTextEditorInput = editorInput;
+        let resource = untitledTextEditorInput.resource;
+        if (untitledTextEditorInput.model.hasAssociatedFilePath) {
+            resource = toLocalResource(resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme);
+        }
+        let languageId;
+        const languageIdCandidate = untitledTextEditorInput.getLanguageId();
+        if (languageIdCandidate !== PLAINTEXT_LANGUAGE_ID) {
+            languageId = languageIdCandidate;
+        }
+        else if (untitledTextEditorInput.model.hasLanguageSetExplicitly) {
+            languageId = languageIdCandidate;
+        }
+        const serialized = {
+            resourceJSON: resource.toJSON(),
+            modeId: languageId,
+            encoding: untitledTextEditorInput.getEncoding()
+        };
+        return JSON.stringify(serialized);
+    }
+    deserialize(instantiationService, serializedEditorInput) {
+        return instantiationService.invokeFunction(accessor => {
+            const deserialized = JSON.parse(serializedEditorInput);
+            const resource = URI.revive(deserialized.resourceJSON);
+            const languageId = deserialized.modeId;
+            const encoding = deserialized.encoding;
+            return accessor.get(ITextEditorService).createTextEditor({ resource, languageId, encoding, forceUntitled: true });
+        });
+    }
+};
+UntitledTextEditorInputSerializer = ( __decorate([
+    ( __param(0, IFilesConfigurationService)),
+    ( __param(1, IWorkbenchEnvironmentService)),
+    ( __param(2, IPathService))
+], UntitledTextEditorInputSerializer));
 let UntitledTextEditorWorkingCopyEditorHandler = class UntitledTextEditorWorkingCopyEditorHandler extends Disposable {
     constructor(workingCopyEditorService, environmentService, pathService, textEditorService, untitledTextEditorService) {
         super();
@@ -45,4 +96,4 @@ UntitledTextEditorWorkingCopyEditorHandler = ( __decorate([
     ( __param(3, ITextEditorService)),
     ( __param(4, IUntitledTextEditorService))
 ], UntitledTextEditorWorkingCopyEditorHandler));
-export { UntitledTextEditorWorkingCopyEditorHandler };
+export { UntitledTextEditorInputSerializer, UntitledTextEditorWorkingCopyEditorHandler };

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

@@ -5,7 +5,13 @@ function getWorkspaceIdentifier(workspaceUri) {
         configPath: workspaceUri
     };
 }
+function getSingleFolderWorkspaceIdentifier(folderUri) {
+    return {
+        id: getWorkspaceId(folderUri),
+        uri: folderUri
+    };
+}
 function getWorkspaceId(uri) {
     return ( hash(( uri.toString())).toString(16));
 }
-export { getWorkspaceIdentifier };
+export { getSingleFolderWorkspaceIdentifier, getWorkspaceIdentifier };