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

package/vscode/src/vs/workbench/services/workingCopy/common/fileWorkingCopyManager.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize } from 'vscode/vscode/vs/nls';
 import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
 import { Promises } from 'vscode/vscode/vs/base/common/async';
@@ -12,10 +13,12 @@ import { SaveSourceRegistry } from 'vscode/vscode/vs/workbench/common/editor';
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService.service';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { StoredFileWorkingCopyState } from '@codingame/monaco-vscode-99f24462-c56d-5407-83fb-2ea9dd33cc8c-common/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy';
 import { StoredFileWorkingCopyManager } from './storedFileWorkingCopyManager.js';
 import { UntitledFileWorkingCopy } from './untitledFileWorkingCopy.js';
 import { UntitledFileWorkingCopyManager } from './untitledFileWorkingCopyManager.js';
 import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service';
+import { SnapshotContext } from '@codingame/monaco-vscode-9d05a43d-c330-5ff1-937e-fde4a3852931-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy';
 import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label.service';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
@@ -45,8 +48,8 @@ import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/prog
 var FileWorkingCopyManager_1;
 let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
     static { FileWorkingCopyManager_1 = this; }
-    static { this.FILE_WORKING_COPY_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyCreate.source', ( localize(7989, "File Created"))); }
-    static { this.FILE_WORKING_COPY_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyReplace.source', ( localize(7990, "File Replaced"))); }
+    static { this.FILE_WORKING_COPY_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyCreate.source', ( localize(12078, "File Created"))); }
+    static { this.FILE_WORKING_COPY_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyReplace.source', ( localize(12079, "File Replaced"))); }
     constructor(workingCopyTypeId, storedWorkingCopyModelFactory, untitledWorkingCopyModelFactory, fileService, lifecycleService, labelService, logService, workingCopyFileService, workingCopyBackupService, uriIdentityService, fileDialogService, filesConfigurationService, workingCopyService, notificationService, workingCopyEditorService, editorService, elevatedFileService, pathService, environmentService, dialogService, decorationsService, progressService) {
         super();
         this.workingCopyTypeId = workingCopyTypeId;
@@ -62,7 +65,7 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         this.environmentService = environmentService;
         this.dialogService = dialogService;
         this.decorationsService = decorationsService;
-        this.stored = this._register(( (new StoredFileWorkingCopyManager(
+        this.stored = this._register(( new StoredFileWorkingCopyManager(
             this.workingCopyTypeId,
             this.storedWorkingCopyModelFactory,
             fileService,
@@ -79,8 +82,8 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
             editorService,
             elevatedFileService,
             progressService
-        ))));
-        this.untitled = this._register(( (new UntitledFileWorkingCopyManager(
+        )));
+        this.untitled = this._register(( new UntitledFileWorkingCopyManager(
             this.workingCopyTypeId,
             this.untitledWorkingCopyModelFactory,
             async (workingCopy, options) => {
@@ -92,7 +95,7 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
             logService,
             workingCopyBackupService,
             workingCopyService
-        ))));
+        )));
         this.onDidCreate = Event.any(this.stored.onDidCreate, this.untitled.onDidCreate);
         this.provideDecorations();
     }
@@ -101,14 +104,14 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
             constructor(stored) {
                 super();
                 this.stored = stored;
-                this.label = ( localize(7991, "File Working Copy Decorations"));
-                this._onDidChange = this._register(( (new Emitter())));
+                this.label = ( localize(12080, "File Working Copy Decorations"));
+                this._onDidChange = this._register(( new Emitter()));
                 this.onDidChange = this._onDidChange.event;
                 this.registerListeners();
             }
             registerListeners() {
                 this._register(this.stored.onDidResolve(workingCopy => {
-                    if (workingCopy.isReadonly() || workingCopy.hasState(4 )) {
+                    if (workingCopy.isReadonly() || workingCopy.hasState(StoredFileWorkingCopyState.ORPHAN)) {
                         this._onDidChange.fire([workingCopy.resource]);
                     }
                 }));
@@ -122,26 +125,26 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
                     return undefined;
                 }
                 const isReadonly = workingCopy.isReadonly();
-                const isOrphaned = workingCopy.hasState(4 );
+                const isOrphaned = workingCopy.hasState(StoredFileWorkingCopyState.ORPHAN);
                 if (isReadonly && isOrphaned) {
                     return {
                         color: listErrorForeground,
                         letter: Codicon.lockSmall,
                         strikethrough: true,
-                        tooltip: ( localize(7992, "Deleted, Read-only")),
+                        tooltip: ( localize(12081, "Deleted, Read-only")),
                     };
                 }
                 else if (isReadonly) {
                     return {
                         letter: Codicon.lockSmall,
-                        tooltip: ( localize(7993, "Read-only")),
+                        tooltip: ( localize(12082, "Read-only")),
                     };
                 }
                 else if (isOrphaned) {
                     return {
                         color: listErrorForeground,
                         strikethrough: true,
-                        tooltip: ( localize(7994, "Deleted")),
+                        tooltip: ( localize(12083, "Deleted")),
                     };
                 }
                 return undefined;
@@ -211,7 +214,7 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         let sourceContents;
         const sourceWorkingCopy = this.get(source);
         if (sourceWorkingCopy?.isResolved()) {
-            sourceContents = await sourceWorkingCopy.model.snapshot(1 , CancellationToken.None);
+            sourceContents = await sourceWorkingCopy.model.snapshot(SnapshotContext.Save, CancellationToken.None);
         }
         else {
             sourceContents = (await this.fileService.readFileStream(source)).value;
@@ -273,17 +276,17 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         const { confirmed } = await this.dialogService.confirm({
             type: 'warning',
             message: ( localize(
-                7995,
+                12084,
                 "'{0}' already exists. Do you want to replace it?",
                 basename(resource)
             )),
             detail: ( localize(
-                7996,
+                12085,
                 "A file or folder with the name '{0}' already exists in the folder '{1}'. Replacing it will overwrite its current contents.",
                 basename(resource),
                 basename(dirname(resource))
             )),
-            primaryButton: ( localize(7997, "&&Replace"))
+            primaryButton: ( localize(12086, "&&Replace"))
         });
         return confirmed;
     }
@@ -291,12 +294,12 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         const { confirmed } = await this.dialogService.confirm({
             type: 'warning',
             message: ( localize(
-                7998,
+                12087,
                 "'{0}' is marked as read-only. Do you want to save anyway?",
                 basename(resource)
             )),
-            detail: ( localize(7999, "Paths can be configured as read-only via settings.")),
-            primaryButton: ( localize(8000, "&&Save Anyway"))
+            detail: ( localize(12088, "Paths can be configured as read-only via settings.")),
+            primaryButton: ( localize(12089, "&&Save Anyway"))
         });
         return confirmed;
     }
@@ -324,26 +327,26 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         ]);
     }
 };
-FileWorkingCopyManager = FileWorkingCopyManager_1 = ( (__decorate([
-    ( (__param(3, IFileService))),
-    ( (__param(4, ILifecycleService))),
-    ( (__param(5, ILabelService))),
-    ( (__param(6, ILogService))),
-    ( (__param(7, IWorkingCopyFileService))),
-    ( (__param(8, IWorkingCopyBackupService))),
-    ( (__param(9, IUriIdentityService))),
-    ( (__param(10, IFileDialogService))),
-    ( (__param(11, IFilesConfigurationService))),
-    ( (__param(12, IWorkingCopyService))),
-    ( (__param(13, INotificationService))),
-    ( (__param(14, IWorkingCopyEditorService))),
-    ( (__param(15, IEditorService))),
-    ( (__param(16, IElevatedFileService))),
-    ( (__param(17, IPathService))),
-    ( (__param(18, IWorkbenchEnvironmentService))),
-    ( (__param(19, IDialogService))),
-    ( (__param(20, IDecorationsService))),
-    ( (__param(21, IProgressService)))
-], FileWorkingCopyManager)));
+FileWorkingCopyManager = FileWorkingCopyManager_1 = ( __decorate([
+    ( __param(3, IFileService)),
+    ( __param(4, ILifecycleService)),
+    ( __param(5, ILabelService)),
+    ( __param(6, ILogService)),
+    ( __param(7, IWorkingCopyFileService)),
+    ( __param(8, IWorkingCopyBackupService)),
+    ( __param(9, IUriIdentityService)),
+    ( __param(10, IFileDialogService)),
+    ( __param(11, IFilesConfigurationService)),
+    ( __param(12, IWorkingCopyService)),
+    ( __param(13, INotificationService)),
+    ( __param(14, IWorkingCopyEditorService)),
+    ( __param(15, IEditorService)),
+    ( __param(16, IElevatedFileService)),
+    ( __param(17, IPathService)),
+    ( __param(18, IWorkbenchEnvironmentService)),
+    ( __param(19, IDialogService)),
+    ( __param(20, IDecorationsService)),
+    ( __param(21, IProgressService))
+], FileWorkingCopyManager));
 
 export { FileWorkingCopyManager };

package/vscode/src/vs/workbench/services/workingCopy/common/storedFileWorkingCopyManager.d.ts

@@ -0,0 +1,96 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { IStoredFileWorkingCopy, IStoredFileWorkingCopyModel, IStoredFileWorkingCopyModelFactory, IStoredFileWorkingCopyResolveOptions, IStoredFileWorkingCopySaveEvent as IBaseStoredFileWorkingCopySaveEvent } from "@codingame/monaco-vscode-99f24462-c56d-5407-83fb-2ea9dd33cc8c-common/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { ILifecycleService } from "vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { ILabelService } from "vscode/vscode/vs/platform/label/common/label.service";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IWorkingCopyFileService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IWorkingCopyBackupService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service";
+import { BaseFileWorkingCopyManager, IBaseFileWorkingCopyManager } from "./abstractFileWorkingCopyManager.js";
+import { INotificationService } from "vscode/vscode/vs/platform/notification/common/notification.service";
+import { IEditorService } from "vscode/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IElevatedFileService } from "vscode/vscode/vs/workbench/services/files/common/elevatedFileService.service";
+import { IFilesConfigurationService } from "vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service";
+import { IWorkingCopyEditorService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService.service";
+import { IWorkingCopyService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service";
+import { IProgressService } from "vscode/vscode/vs/platform/progress/common/progress.service";
+export interface IStoredFileWorkingCopyManager<M extends IStoredFileWorkingCopyModel> extends IBaseFileWorkingCopyManager<M, IStoredFileWorkingCopy<M>> {
+    readonly onDidResolve: Event<IStoredFileWorkingCopy<M>>;
+    readonly onDidChangeDirty: Event<IStoredFileWorkingCopy<M>>;
+    readonly onDidChangeReadonly: Event<IStoredFileWorkingCopy<M>>;
+    readonly onDidChangeOrphaned: Event<IStoredFileWorkingCopy<M>>;
+    readonly onDidSaveError: Event<IStoredFileWorkingCopy<M>>;
+    readonly onDidSave: Event<IStoredFileWorkingCopySaveEvent<M>>;
+    readonly onDidRevert: Event<IStoredFileWorkingCopy<M>>;
+    readonly onDidRemove: Event<URI>;
+    resolve(resource: URI, options?: IStoredFileWorkingCopyManagerResolveOptions): Promise<IStoredFileWorkingCopy<M>>;
+    canDispose(workingCopy: IStoredFileWorkingCopy<M>): true | Promise<true>;
+}
+export interface IStoredFileWorkingCopySaveEvent<M extends IStoredFileWorkingCopyModel> extends IBaseStoredFileWorkingCopySaveEvent {
+    readonly workingCopy: IStoredFileWorkingCopy<M>;
+}
+export interface IStoredFileWorkingCopyManagerResolveOptions extends IStoredFileWorkingCopyResolveOptions {
+    readonly reload?: {
+        readonly async: boolean;
+        readonly force?: boolean;
+    };
+}
+export declare class StoredFileWorkingCopyManager<M extends IStoredFileWorkingCopyModel> extends BaseFileWorkingCopyManager<M, IStoredFileWorkingCopy<M>> implements IStoredFileWorkingCopyManager<M> {
+    private readonly workingCopyTypeId;
+    private readonly modelFactory;
+    private readonly lifecycleService;
+    private readonly labelService;
+    private readonly workingCopyFileService;
+    private readonly uriIdentityService;
+    private readonly filesConfigurationService;
+    private readonly workingCopyService;
+    private readonly notificationService;
+    private readonly workingCopyEditorService;
+    private readonly editorService;
+    private readonly elevatedFileService;
+    private readonly progressService;
+    private readonly _onDidResolve;
+    readonly onDidResolve: Event<IStoredFileWorkingCopy<M>>;
+    private readonly _onDidChangeDirty;
+    readonly onDidChangeDirty: Event<IStoredFileWorkingCopy<M>>;
+    private readonly _onDidChangeReadonly;
+    readonly onDidChangeReadonly: Event<IStoredFileWorkingCopy<M>>;
+    private readonly _onDidChangeOrphaned;
+    readonly onDidChangeOrphaned: Event<IStoredFileWorkingCopy<M>>;
+    private readonly _onDidSaveError;
+    readonly onDidSaveError: Event<IStoredFileWorkingCopy<M>>;
+    private readonly _onDidSave;
+    readonly onDidSave: Event<IStoredFileWorkingCopySaveEvent<M>>;
+    private readonly _onDidRevert;
+    readonly onDidRevert: Event<IStoredFileWorkingCopy<M>>;
+    private readonly _onDidRemove;
+    readonly onDidRemove: Event<URI>;
+    private readonly mapResourceToWorkingCopyListeners;
+    private readonly mapResourceToPendingWorkingCopyResolve;
+    private readonly workingCopyResolveQueue;
+    constructor(workingCopyTypeId: string, modelFactory: IStoredFileWorkingCopyModelFactory<M>, fileService: IFileService, lifecycleService: ILifecycleService, labelService: ILabelService, logService: ILogService, workingCopyFileService: IWorkingCopyFileService, workingCopyBackupService: IWorkingCopyBackupService, uriIdentityService: IUriIdentityService, filesConfigurationService: IFilesConfigurationService, workingCopyService: IWorkingCopyService, notificationService: INotificationService, workingCopyEditorService: IWorkingCopyEditorService, editorService: IEditorService, elevatedFileService: IElevatedFileService, progressService: IProgressService);
+    private registerListeners;
+    private onBeforeShutdownWeb;
+    private onWillShutdownDesktop;
+    private onDidChangeFileSystemProviderCapabilities;
+    private onDidChangeFileSystemProviderRegistrations;
+    private onDidFilesChange;
+    private queueWorkingCopyReloads;
+    private queueWorkingCopyReload;
+    private readonly mapCorrelationIdToWorkingCopiesToRestore;
+    private onWillRunWorkingCopyFileOperation;
+    private onDidFailWorkingCopyFileOperation;
+    private onDidRunWorkingCopyFileOperation;
+    private reload;
+    resolve(resource: URI, options?: IStoredFileWorkingCopyManagerResolveOptions): Promise<IStoredFileWorkingCopy<M>>;
+    private doResolve;
+    private joinPendingResolves;
+    private doJoinPendingResolves;
+    private registerWorkingCopy;
+    protected remove(resource: URI): boolean;
+    canDispose(workingCopy: IStoredFileWorkingCopy<M>): true | Promise<true>;
+    private doCanDispose;
+    dispose(): void;
+}

package/vscode/src/vs/workbench/services/workingCopy/common/storedFileWorkingCopyManager.js

@@ -1,10 +1,12 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize } from 'vscode/vscode/vs/nls';
 import { DisposableStore, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
-import { StoredFileWorkingCopy } from 'vscode/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy';
+import { StoredFileWorkingCopyState, StoredFileWorkingCopy } from '@codingame/monaco-vscode-99f24462-c56d-5407-83fb-2ea9dd33cc8c-common/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy';
 import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
 import { ResourceQueue, Promises } from 'vscode/vscode/vs/base/common/async';
+import { FileChangeType, FileOperation } from 'vscode/vscode/vs/platform/files/common/files';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
@@ -24,6 +26,7 @@ import { IWorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/w
 import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service';
 import { isWeb } from 'vscode/vscode/vs/base/common/platform';
 import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
+import { SnapshotContext } from '@codingame/monaco-vscode-9d05a43d-c330-5ff1-937e-fde4a3852931-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy';
 import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress.service';
 
 let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends BaseFileWorkingCopyManager {
@@ -42,26 +45,26 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
         this.editorService = editorService;
         this.elevatedFileService = elevatedFileService;
         this.progressService = progressService;
-        this._onDidResolve = this._register(( (new Emitter())));
+        this._onDidResolve = this._register(( new Emitter()));
         this.onDidResolve = this._onDidResolve.event;
-        this._onDidChangeDirty = this._register(( (new Emitter())));
+        this._onDidChangeDirty = this._register(( new Emitter()));
         this.onDidChangeDirty = this._onDidChangeDirty.event;
-        this._onDidChangeReadonly = this._register(( (new Emitter())));
+        this._onDidChangeReadonly = this._register(( new Emitter()));
         this.onDidChangeReadonly = this._onDidChangeReadonly.event;
-        this._onDidChangeOrphaned = this._register(( (new Emitter())));
+        this._onDidChangeOrphaned = this._register(( new Emitter()));
         this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
-        this._onDidSaveError = this._register(( (new Emitter())));
+        this._onDidSaveError = this._register(( new Emitter()));
         this.onDidSaveError = this._onDidSaveError.event;
-        this._onDidSave = this._register(( (new Emitter())));
+        this._onDidSave = this._register(( new Emitter()));
         this.onDidSave = this._onDidSave.event;
-        this._onDidRevert = this._register(( (new Emitter())));
+        this._onDidRevert = this._register(( new Emitter()));
         this.onDidRevert = this._onDidRevert.event;
-        this._onDidRemove = this._register(( (new Emitter())));
+        this._onDidRemove = this._register(( new Emitter()));
         this.onDidRemove = this._onDidRemove.event;
-        this.mapResourceToWorkingCopyListeners = ( (new ResourceMap()));
-        this.mapResourceToPendingWorkingCopyResolve = ( (new ResourceMap()));
-        this.workingCopyResolveQueue = this._register(( (new ResourceQueue())));
-        this.mapCorrelationIdToWorkingCopiesToRestore = ( (new Map()));
+        this.mapResourceToWorkingCopyListeners = ( new ResourceMap());
+        this.mapResourceToPendingWorkingCopyResolve = ( new ResourceMap());
+        this.workingCopyResolveQueue = this._register(( new ResourceQueue()));
+        this.mapCorrelationIdToWorkingCopiesToRestore = ( new Map());
         this.registerListeners();
     }
     registerListeners() {
@@ -75,23 +78,23 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
             this._register(this.lifecycleService.onBeforeShutdown(event => event.veto(this.onBeforeShutdownWeb(), 'veto.fileWorkingCopyManager')));
         }
         else {
-            this._register(this.lifecycleService.onWillShutdown(event => event.join(this.onWillShutdownDesktop(), { id: 'join.fileWorkingCopyManager', label: ( localize(10932, "Saving working copies")) })));
+            this._register(this.lifecycleService.onWillShutdown(event => event.join(this.onWillShutdownDesktop(), { id: 'join.fileWorkingCopyManager', label: ( localize(12107, "Saving working copies")) })));
         }
     }
     onBeforeShutdownWeb() {
-        if (( (this.workingCopies.some(
-            workingCopy => workingCopy.hasState(2 )
-        )))) {
+        if (( this.workingCopies.some(
+            workingCopy => workingCopy.hasState(StoredFileWorkingCopyState.PENDING_SAVE)
+        ))) {
             return true;
         }
         return false;
     }
     async onWillShutdownDesktop() {
         let pendingSavedWorkingCopies;
-        while ((pendingSavedWorkingCopies = this.workingCopies.filter(workingCopy => workingCopy.hasState(2 ))).length > 0) {
-            await Promises.settled(( (pendingSavedWorkingCopies.map(
-                workingCopy => workingCopy.joinState(2 )
-            ))));
+        while ((pendingSavedWorkingCopies = this.workingCopies.filter(workingCopy => workingCopy.hasState(StoredFileWorkingCopyState.PENDING_SAVE))).length > 0) {
+            await Promises.settled(( pendingSavedWorkingCopies.map(
+                workingCopy => workingCopy.joinState(StoredFileWorkingCopyState.PENDING_SAVE)
+            )));
         }
     }
     onDidChangeFileSystemProviderCapabilities(e) {
@@ -116,7 +119,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
                 resolveWorkingCopy = schemeOrEvent === workingCopy.resource.scheme;
             }
             else {
-                resolveWorkingCopy = schemeOrEvent.contains(workingCopy.resource, 0 , 1 );
+                resolveWorkingCopy = schemeOrEvent.contains(workingCopy.resource, FileChangeType.UPDATED, FileChangeType.ADDED);
             }
             if (resolveWorkingCopy) {
                 this.queueWorkingCopyReload(workingCopy);
@@ -137,7 +140,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
         }
     }
     onWillRunWorkingCopyFileOperation(e) {
-        if (e.operation === 2  || e.operation === 3 ) {
+        if (e.operation === FileOperation.MOVE || e.operation === FileOperation.COPY) {
             e.waitUntil((async () => {
                 const workingCopiesToRestore = [];
                 for (const { source, target } of e.files) {
@@ -163,7 +166,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
                             workingCopiesToRestore.push({
                                 source: sourceResource,
                                 target: targetResource,
-                                snapshot: sourceWorkingCopy.isDirty() ? await sourceWorkingCopy.model?.snapshot(1 , CancellationToken.None) : undefined
+                                snapshot: sourceWorkingCopy.isDirty() ? await sourceWorkingCopy.model?.snapshot(SnapshotContext.Save, CancellationToken.None) : undefined
                             });
                         }
                     }
@@ -173,7 +176,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
         }
     }
     onDidFailWorkingCopyFileOperation(e) {
-        if (((e.operation === 2  || e.operation === 3) )) {
+        if ((e.operation === FileOperation.MOVE || e.operation === FileOperation.COPY)) {
             const workingCopiesToRestore = this.mapCorrelationIdToWorkingCopiesToRestore.get(e.correlationId);
             if (workingCopiesToRestore) {
                 this.mapCorrelationIdToWorkingCopiesToRestore.delete(e.correlationId);
@@ -187,7 +190,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
     }
     onDidRunWorkingCopyFileOperation(e) {
         switch (e.operation) {
-            case 0 :
+            case FileOperation.CREATE:
                 e.waitUntil((async () => {
                     for (const { target } of e.files) {
                         const workingCopy = this.get(target);
@@ -197,19 +200,19 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
                     }
                 })());
                 break;
-            case 2 :
-            case 3 :
+            case FileOperation.MOVE:
+            case FileOperation.COPY:
                 e.waitUntil((async () => {
                     const workingCopiesToRestore = this.mapCorrelationIdToWorkingCopiesToRestore.get(e.correlationId);
                     if (workingCopiesToRestore) {
                         this.mapCorrelationIdToWorkingCopiesToRestore.delete(e.correlationId);
-                        await Promises.settled(( (workingCopiesToRestore.map(async (workingCopyToRestore) => {
+                        await Promises.settled(( workingCopiesToRestore.map(async (workingCopyToRestore) => {
                             const target = this.uriIdentityService.asCanonicalUri(workingCopyToRestore.target);
                             await this.resolve(target, {
                                 reload: { async: false },
                                 contents: workingCopyToRestore.snapshot
                             });
-                        }))));
+                        })));
                     }
                 })());
                 break;
@@ -217,7 +220,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
     }
     async reload(workingCopy) {
         await this.joinPendingResolves(workingCopy.resource);
-        if (workingCopy.isDirty() || workingCopy.isDisposed() || !( (this.has(workingCopy.resource)))) {
+        if (workingCopy.isDirty() || workingCopy.isDisposed() || !( this.has(workingCopy.resource))) {
             return;
         }
         await this.doResolve(workingCopy, { reload: { async: false } });
@@ -273,7 +276,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
         }
         else {
             didCreateWorkingCopy = true;
-            workingCopy = ( (new StoredFileWorkingCopy(
+            workingCopy = ( new StoredFileWorkingCopy(
                 this.workingCopyTypeId,
                 resource,
                 this.labelService.getUriBasenameLabel(resource),
@@ -290,7 +293,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
                 this.editorService,
                 this.elevatedFileService,
                 this.progressService
-            )));
+            ));
             workingCopyResolve = workingCopy.resolve(resolveOptions);
             this.registerWorkingCopy(workingCopy);
         }
@@ -327,7 +330,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
     }
     async doJoinPendingResolves(resource) {
         let currentWorkingCopyResolve;
-        while (( (this.mapResourceToPendingWorkingCopyResolve.has(resource)))) {
+        while (( this.mapResourceToPendingWorkingCopyResolve.has(resource))) {
             const nextPendingWorkingCopyResolve = this.mapResourceToPendingWorkingCopyResolve.get(resource);
             if (nextPendingWorkingCopyResolve === currentWorkingCopyResolve) {
                 return;
@@ -341,7 +344,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
         }
     }
     registerWorkingCopy(workingCopy) {
-        const workingCopyListeners = ( (new DisposableStore()));
+        const workingCopyListeners = ( new DisposableStore());
         workingCopyListeners.add(workingCopy.onDidResolve(() => this._onDidResolve.fire(workingCopy)));
         workingCopyListeners.add(workingCopy.onDidChangeDirty(() => this._onDidChangeDirty.fire(workingCopy)));
         workingCopyListeners.add(workingCopy.onDidChangeReadonly(() => this._onDidChangeReadonly.fire(workingCopy)));
@@ -365,7 +368,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
     }
     canDispose(workingCopy) {
         if (workingCopy.isDisposed() ||
-            (!( (this.mapResourceToPendingWorkingCopyResolve.has(workingCopy.resource))) && !workingCopy.isDirty())) {
+            (!( this.mapResourceToPendingWorkingCopyResolve.has(workingCopy.resource)) && !workingCopy.isDirty())) {
             return true;
         }
         return this.doCanDispose(workingCopy);
@@ -385,25 +388,25 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
     dispose() {
         super.dispose();
         this.mapResourceToPendingWorkingCopyResolve.clear();
-        dispose(( (this.mapResourceToWorkingCopyListeners.values())));
+        dispose(( this.mapResourceToWorkingCopyListeners.values()));
         this.mapResourceToWorkingCopyListeners.clear();
     }
 };
-StoredFileWorkingCopyManager = ( (__decorate([
-    ( (__param(2, IFileService))),
-    ( (__param(3, ILifecycleService))),
-    ( (__param(4, ILabelService))),
-    ( (__param(5, ILogService))),
-    ( (__param(6, IWorkingCopyFileService))),
-    ( (__param(7, IWorkingCopyBackupService))),
-    ( (__param(8, IUriIdentityService))),
-    ( (__param(9, IFilesConfigurationService))),
-    ( (__param(10, IWorkingCopyService))),
-    ( (__param(11, INotificationService))),
-    ( (__param(12, IWorkingCopyEditorService))),
-    ( (__param(13, IEditorService))),
-    ( (__param(14, IElevatedFileService))),
-    ( (__param(15, IProgressService)))
-], StoredFileWorkingCopyManager)));
+StoredFileWorkingCopyManager = ( __decorate([
+    ( __param(2, IFileService)),
+    ( __param(3, ILifecycleService)),
+    ( __param(4, ILabelService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IWorkingCopyFileService)),
+    ( __param(7, IWorkingCopyBackupService)),
+    ( __param(8, IUriIdentityService)),
+    ( __param(9, IFilesConfigurationService)),
+    ( __param(10, IWorkingCopyService)),
+    ( __param(11, INotificationService)),
+    ( __param(12, IWorkingCopyEditorService)),
+    ( __param(13, IEditorService)),
+    ( __param(14, IElevatedFileService)),
+    ( __param(15, IProgressService))
+], StoredFileWorkingCopyManager));
 
 export { StoredFileWorkingCopyManager };

package/vscode/src/vs/workbench/services/workingCopy/common/untitledFileWorkingCopy.d.ts

@@ -0,0 +1,74 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { VSBufferReadableStream } from "vscode/vscode/vs/base/common/buffer";
+import { IWorkingCopyBackup, IWorkingCopySaveEvent } from "@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common/vscode/vs/workbench/services/workingCopy/common/workingCopy";
+import { IFileWorkingCopy, IFileWorkingCopyModel, IFileWorkingCopyModelFactory } from "@codingame/monaco-vscode-9d05a43d-c330-5ff1-937e-fde4a3852931-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IWorkingCopyService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service";
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { ISaveOptions } from "vscode/vscode/vs/workbench/common/editor";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IWorkingCopyBackupService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service";
+export interface IUntitledFileWorkingCopyModelFactory<M extends IUntitledFileWorkingCopyModel> extends IFileWorkingCopyModelFactory<M> {
+}
+export interface IUntitledFileWorkingCopyModel extends IFileWorkingCopyModel {
+    readonly onDidChangeContent: Event<IUntitledFileWorkingCopyModelContentChangedEvent>;
+}
+export interface IUntitledFileWorkingCopyModelContentChangedEvent {
+    readonly isInitial: boolean;
+}
+export interface IUntitledFileWorkingCopy<M extends IUntitledFileWorkingCopyModel> extends IFileWorkingCopy<M> {
+    readonly hasAssociatedFilePath: boolean;
+    isResolved(): this is IResolvedUntitledFileWorkingCopy<M>;
+}
+export interface IResolvedUntitledFileWorkingCopy<M extends IUntitledFileWorkingCopyModel> extends IUntitledFileWorkingCopy<M> {
+    readonly model: M;
+}
+export interface IUntitledFileWorkingCopySaveDelegate<M extends IUntitledFileWorkingCopyModel> {
+    (workingCopy: IUntitledFileWorkingCopy<M>, options?: ISaveOptions): Promise<boolean>;
+}
+export interface IUntitledFileWorkingCopyInitialContents {
+    readonly value: VSBufferReadableStream;
+    readonly markModified?: boolean;
+}
+export declare class UntitledFileWorkingCopy<M extends IUntitledFileWorkingCopyModel> extends Disposable implements IUntitledFileWorkingCopy<M> {
+    readonly typeId: string;
+    readonly resource: URI;
+    readonly name: string;
+    readonly hasAssociatedFilePath: boolean;
+    private readonly isScratchpad;
+    private readonly initialContents;
+    private readonly modelFactory;
+    private readonly saveDelegate;
+    private readonly workingCopyBackupService;
+    private readonly logService;
+    readonly capabilities: number;
+    private _model;
+    get model(): M | undefined;
+    private readonly _onDidChangeContent;
+    readonly onDidChangeContent: Event<void>;
+    private readonly _onDidChangeDirty;
+    readonly onDidChangeDirty: Event<void>;
+    private readonly _onDidSave;
+    readonly onDidSave: Event<IWorkingCopySaveEvent>;
+    private readonly _onDidRevert;
+    readonly onDidRevert: Event<void>;
+    private readonly _onWillDispose;
+    readonly onWillDispose: Event<void>;
+    constructor(typeId: string, resource: URI, name: string, hasAssociatedFilePath: boolean, isScratchpad: boolean, initialContents: IUntitledFileWorkingCopyInitialContents | undefined, modelFactory: IUntitledFileWorkingCopyModelFactory<M>, saveDelegate: IUntitledFileWorkingCopySaveDelegate<M>, workingCopyService: IWorkingCopyService, workingCopyBackupService: IWorkingCopyBackupService, logService: ILogService);
+    private modified;
+    isDirty(): boolean;
+    isModified(): boolean;
+    private setModified;
+    resolve(): Promise<void>;
+    private doCreateModel;
+    private installModelListeners;
+    private onModelContentChanged;
+    isResolved(): this is IResolvedUntitledFileWorkingCopy<M>;
+    get backupDelay(): number | undefined;
+    backup(token: CancellationToken): Promise<IWorkingCopyBackup>;
+    save(options?: ISaveOptions): Promise<boolean>;
+    revert(): Promise<void>;
+    dispose(): void;
+    private trace;
+}