@codingame/monaco-vscode-files-service-override 26.1.1 → 26.2.0

package/index.d.ts

@@ -146,7 +146,7 @@ declare class OverlayFileSystemProvider implements IFileSystemProviderWithFileRe
     delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
     rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
 }
-declare class DelegateFileSystemProvider implements IFileSystemProvider {
+declare class DelegateFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
     private options;
     constructor(options: {
         delegate: IFileSystemProvider;
@@ -159,8 +159,8 @@ declare class DelegateFileSystemProvider implements IFileSystemProvider {
         type: FileChangeType;
         resource: URI;
     }[]>;
-    readFile: ((resource: URI) => Promise<Uint8Array>) | undefined;
-    writeFile: ((resource: URI, content: Uint8Array, opts: IFileWriteOptions) => Promise<void>) | undefined;
+    readFile: (resource: URI) => Promise<Uint8Array>;
+    writeFile: (resource: URI, content: Uint8Array, opts: IFileWriteOptions) => Promise<void>;
     watch(resource: URI, opts: IWatchOptions): IDisposable;
     stat(resource: URI): Promise<IStat>;
     mkdir(resource: URI): Promise<void>;

package/index.js

@@ -474,7 +474,8 @@ class OverlayFileSystemProvider {
         this.onDidChangeOverlays = this._onDidChangeOverlays.event;
         this.capabilities = FileSystemProviderCapabilities.FileReadWrite |
             FileSystemProviderCapabilities.PathCaseSensitive |
-            FileSystemProviderCapabilities.FileReadStream;
+            FileSystemProviderCapabilities.FileReadStream |
+            FileSystemProviderCapabilities.FileAppend;
     }
     register(priority, provider) {
         const item = { priority, provider };
@@ -503,7 +504,7 @@ class OverlayFileSystemProvider {
         if (this.delegates.length === 0) {
             throw createFileSystemProviderError('No delegate', FileSystemProviderErrorCode.Unavailable);
         }
-        let firstError;
+        const errors = [];
         for (const delegate of this.delegates) {
             if (token != null && token.isCancellationRequested) {
                 throw new Error('Cancelled');
@@ -512,19 +513,24 @@ class OverlayFileSystemProvider {
                 return await caller(delegate);
             }
             catch (err) {
-                firstError ?? (firstError = err);
-                if (err instanceof FileSystemProviderError &&
-                    [
+                errors.push(err);
+                if (err instanceof FileSystemProviderError) {
+                    if ([
                         FileSystemProviderErrorCode.NoPermissions,
                         FileSystemProviderErrorCode.FileNotFound,
                         FileSystemProviderErrorCode.Unavailable
                     ].includes(err.code)) {
-                    continue;
+                        continue;
+                    }
                 }
                 throw err;
             }
         }
-        throw firstError;
+        const fileSystemErrors = errors?.filter((err) => err instanceof FileSystemProviderError);
+        const mostRelevantErrors = fileSystemErrors.find((err) => err.code === FileSystemProviderErrorCode.FileNotFound) ??
+            fileSystemErrors[0] ??
+            errors[0];
+        throw mostRelevantErrors;
     }
     async writeToDelegates(resource, caller) {
         if (this.delegates.length === 0) {
@@ -661,18 +667,27 @@ class DelegateFileSystemProvider {
             ? (resource) => {
                 return this.options.delegate.readFile(this.options.toDelegate(resource));
             }
-            : undefined;
+            : () => {
+                throw createFileSystemProviderError('No delegate', FileSystemProviderErrorCode.Unavailable);
+            };
         this.writeFile = this.options.delegate.writeFile != null
             ? (resource, content, opts) => {
                 return this.options.delegate.writeFile(this.options.toDelegate(resource), content, opts);
             }
-            : undefined;
+            : () => {
+                throw createFileSystemProviderError('No delegate', FileSystemProviderErrorCode.Unavailable);
+            };
     }
     get capabilities() {
         return this.options.delegate.capabilities;
     }
     watch(resource, opts) {
-        return this.options.delegate.watch(this.options.toDelegate(resource), opts);
+        try {
+            return this.options.delegate.watch(this.options.toDelegate(resource), opts);
+        }
+        catch {
+        }
+        return Disposable.None;
     }
     stat(resource) {
         return this.options.delegate.stat(this.options.toDelegate(resource));

package/package.json

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

package/vscode/src/vs/workbench/services/textfile/browser/textFileService.js

@@ -56,10 +56,10 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         AbstractTextFileService_1 = this;
     }
     static {
-        this.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource("textFileCreate.source", ( localize(14690, "File Created")));
+        this.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource("textFileCreate.source", ( localize(14880, "File Created")));
     }
     static {
-        this.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource("textFileOverwrite.source", ( localize(14691, "File Replaced")));
+        this.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource("textFileOverwrite.source", ( localize(14881, "File Replaced")));
     }
     constructor(
         fileService,
@@ -108,7 +108,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             constructor(files) {
                 super();
                 this.files = files;
-                this.label = ( localize(14692, "Text File Model Decorations"));
+                this.label = ( localize(14882, "Text File Model Decorations"));
                 this._onDidChange = this._register(( new Emitter()));
                 this.onDidChange = this._onDidChange.event;
                 this.registerListeners();
@@ -143,20 +143,20 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
                         color: listErrorForeground,
                         letter: Codicon.lockSmall,
                         strikethrough: true,
-                        tooltip: ( localize(14693, "Deleted, Read-only"))
+                        tooltip: ( localize(14883, "Deleted, Read-only"))
                     };
                 }
                 else if (isReadonly) {
                     return {
                         letter: Codicon.lockSmall,
-                        tooltip: ( localize(14694, "Read-only"))
+                        tooltip: ( localize(14884, "Read-only"))
                     };
                 }
                 else if (isOrphaned) {
                     return {
                         color: listErrorForeground,
                         strikethrough: true,
-                        tooltip: ( localize(14695, "Deleted"))
+                        tooltip: ( localize(14885, "Deleted"))
                     };
                 }
                 return undefined;
@@ -207,7 +207,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         } catch (error) {
             cts.dispose(true);
             if (error.decodeStreamErrorKind === DecodeStreamErrorKind.STREAM_IS_BINARY) {
-                throw ( new TextFileOperationError(( localize(14696, "File seems to be binary and cannot be opened as text")), TextFileOperationResult.FILE_IS_BINARY, options));
+                throw ( new TextFileOperationError(( localize(14886, "File seems to be binary and cannot be opened as text")), TextFileOperationResult.FILE_IS_BINARY, options));
             }
             else {
                 throw error;
@@ -481,17 +481,17 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         } = await this.dialogService.confirm({
             type: "warning",
             message: ( localize(
-                14697,
+                14887,
                 "'{0}' already exists. Do you want to replace it?",
                 basename(resource)
             )),
             detail: ( localize(
-                14698,
+                14888,
                 "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(14699, "&&Replace"))
+            primaryButton: ( localize(14889, "&&Replace"))
         });
         return confirmed;
     }
@@ -501,12 +501,12 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         } = await this.dialogService.confirm({
             type: "warning",
             message: ( localize(
-                14700,
+                14890,
                 "'{0}' is marked as read-only. Do you want to save anyway?",
                 basename(resource)
             )),
-            detail: ( localize(14701, "Paths can be configured as read-only via settings.")),
-            primaryButton: ( localize(14702, "&&Save Anyway"))
+            detail: ( localize(14891, "Paths can be configured as read-only via settings.")),
+            primaryButton: ( localize(14892, "&&Save Anyway"))
         });
         return confirmed;
     }

package/vscode/src/vs/workbench/services/textfile/common/textFileEditorModelManager.js

@@ -69,7 +69,7 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
             return {
                 onSaveError(error, model) {
                     notificationService.error(( localize(
-                        14706,
+                        14896,
                         "Failed to save '{0}': {1}",
                         model.name,
                         toErrorMessage(error, false)

package/vscode/src/vs/workbench/services/textfile/common/textFileSaveParticipant.js

@@ -26,13 +26,13 @@ let TextFileSaveParticipant = class TextFileSaveParticipant extends Disposable {
         const cts = ( new CancellationTokenSource(token));
         model.textEditorModel?.pushStackElement();
         progress.report({
-            message: ( localize(14707, "Running Code Actions and Formatters..."))
+            message: ( localize(14897, "Running Code Actions and Formatters..."))
         });
         let bubbleCancel = false;
         await this.progressService.withProgress({
             priority: NotificationPriority.URGENT,
             location: ProgressLocation.Notification,
-            cancellable: ( localize(14708, "Skip")),
+            cancellable: ( localize(14898, "Skip")),
             delay: model.isDirty() ? 5000 : 3000
         }, async progress => {
             const participants = Array.from(this.saveParticipants).sort((a, b) => {