@codingame/monaco-vscode-working-copy-service-override 37.2.0 → 37.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-working-copy-service-override",
-  "version": "37.2.0",
+  "version": "37.3.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - working-copy service-override",
   "keywords": [],
@@ -15,8 +15,8 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "37.2.0",
-    "@codingame/monaco-vscode-files-service-override": "37.2.0"
+    "@codingame/monaco-vscode-api": "37.3.0",
+    "@codingame/monaco-vscode-files-service-override": "37.3.0"
   },
   "main": "index.js",
   "module": "index.js",

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

@@ -33,16 +33,18 @@ class WorkingCopyBackupsModel {
         try {
             const backupRootStat = await this.fileService.resolve(this.backupRoot);
             if (backupRootStat.children) {
-                await Promises.settled(( backupRootStat.children.filter(child => child.isDirectory).map(async backupSchemaFolder => {
-                    const backupSchemaFolderStat = await this.fileService.resolve(backupSchemaFolder.resource);
-                    if (backupSchemaFolderStat.children) {
-                        for (const backupForSchema of backupSchemaFolderStat.children) {
-                            if (!backupForSchema.isDirectory) {
-                                this.add(backupForSchema.resource);
+                await Promises.settled(
+                    backupRootStat.children.filter(child => child.isDirectory).map(async backupSchemaFolder => {
+                        const backupSchemaFolderStat = await this.fileService.resolve(backupSchemaFolder.resource);
+                        if (backupSchemaFolderStat.children) {
+                            for (const backupForSchema of backupSchemaFolderStat.children) {
+                                if (!backupForSchema.isDirectory) {
+                                    this.add(backupForSchema.resource);
+                                }
                             }
                         }
-                    }
-                })));
+                    })
+                );
             }
         } catch (error) {}
     }
@@ -219,11 +221,11 @@ let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Di
             for (const exceptWorkingCopy of except) {
                 exceptMap.set(this.toBackupResource(exceptWorkingCopy), true);
             }
-            await Promises.settled(( model.get().map(async backupResource => {
+            await Promises.settled(model.get().map(async backupResource => {
                 if (!( exceptMap.has(backupResource))) {
                     await this.doDiscardBackup(backupResource);
                 }
-            })));
+            }));
         }
         else {
             await this.deleteIgnoreFileNotFound(this.backupWorkspaceHome);
@@ -261,7 +263,9 @@ let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Di
     async getBackups() {
         const model = await this.ready;
         await this.joinBackups();
-        const backups = await Promise.all(( model.get().map(backupResource => this.resolveIdentifier(backupResource, model))));
+        const backups = await Promise.all(
+            model.get().map(backupResource => this.resolveIdentifier(backupResource, model))
+        );
         return coalesce(backups);
     }
     async resolveIdentifier(backupResource, model) {
@@ -410,10 +414,10 @@ class InMemoryWorkingCopyBackupService extends Disposable {
         return undefined;
     }
     async getBackups() {
-        return ( Array.from(this.backups.entries()).map(([resource, backup]) => ({
+        return Array.from(this.backups.entries()).map(([resource, backup]) => ({
             typeId: backup.typeId,
             resource
-        })));
+        }));
     }
     async discardBackup(identifier) {
         this.backups.delete(this.toBackupResource(identifier));

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

@@ -273,24 +273,24 @@ class WorkingCopyBackupTracker extends Disposable {
             restoredBackups.add(unrestoredBackup);
         }
         if (nonOpenedEditorsForBackups.size > 0) {
-            await this.editorService.openEditors(( [...nonOpenedEditorsForBackups].map(nonOpenedEditorForBackup => ({
+            await this.editorService.openEditors([...nonOpenedEditorsForBackups].map(nonOpenedEditorForBackup => ({
                 editor: nonOpenedEditorForBackup,
                 options: {
                     pinned: true,
                     preserveFocus: true,
                     inactive: true
                 }
-            }))));
+            })));
             for (const nonOpenedEditorForBackup of nonOpenedEditorsForBackups) {
                 openedEditorsForBackups.add(nonOpenedEditorForBackup);
             }
         }
-        await Promises.settled(( [...openedEditorsForBackups].map(async openedEditorForBackup => {
+        await Promises.settled([...openedEditorsForBackups].map(async openedEditorForBackup => {
             if (this.editorService.isVisible(openedEditorForBackup)) {
                 return;
             }
             return openedEditorForBackup.resolve();
-        })));
+        }));
         for (const restoredBackup of restoredBackups) {
             this.unrestoredBackups.delete(restoredBackup);
         }

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

@@ -36,7 +36,7 @@ class WorkingCopyHistoryModel {
         this.ENTRIES_FILE = "entries.json";
     }
     static {
-        this.FILE_SAVED_SOURCE = SaveSourceRegistry.registerSource("default.source", ( localize(20418, "File Saved")));
+        this.FILE_SAVED_SOURCE = SaveSourceRegistry.registerSource("default.source", ( localize(22561, "File Saved")));
     }
     static {
         this.SETTINGS = {
@@ -371,14 +371,14 @@ class WorkingCopyHistoryModel {
         const serializedModel = {
             version: 1,
             resource: ( workingCopyResource.toString()),
-            entries: ( this.entries.map(entry => {
+            entries: this.entries.map(entry => {
                 return {
                     id: entry.id,
                     source: entry.source !== WorkingCopyHistoryModel.FILE_SAVED_SOURCE ? entry.source : undefined,
                     sourceDescription: entry.sourceDescription,
                     timestamp: entry.timestamp
                 };
-            }))
+            })
         };
         await this.fileService.writeFile(
             historyEntriesListingFile,
@@ -429,10 +429,10 @@ let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposab
         WorkingCopyHistoryService_1 = this;
     }
     static {
-        this.FILE_MOVED_SOURCE = SaveSourceRegistry.registerSource("moved.source", ( localize(20419, "File Moved")));
+        this.FILE_MOVED_SOURCE = SaveSourceRegistry.registerSource("moved.source", ( localize(22562, "File Moved")));
     }
     static {
-        this.FILE_RENAMED_SOURCE = SaveSourceRegistry.registerSource("renamed.source", ( localize(20420, "File Renamed")));
+        this.FILE_RENAMED_SOURCE = SaveSourceRegistry.registerSource("renamed.source", ( localize(22563, "File Renamed")));
     }
     constructor(
         fileService,
@@ -684,7 +684,7 @@ let NativeWorkingCopyHistoryService = class NativeWorkingCopyHistoryService exte
         this.storeAllCts.dispose(true);
         e.join(this.storeAll(e.token), {
             id: "join.workingCopyHistory",
-            label: ( localize(20421, "Saving local history"))
+            label: ( localize(22564, "Saving local history"))
         });
     }
     onDidChangeModels() {

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

@@ -33,7 +33,7 @@ let WorkingCopyHistoryTracker = class WorkingCopyHistoryTracker extends Disposab
         };
     }
     static {
-        this.UNDO_REDO_SAVE_SOURCE = SaveSourceRegistry.registerSource("undoRedo.source", ( localize(20422, "Undo / Redo")));
+        this.UNDO_REDO_SAVE_SOURCE = SaveSourceRegistry.registerSource("undoRedo.source", ( localize(22565, "Undo / Redo")));
     }
     constructor(
         workingCopyService,