@codingame/monaco-vscode-files-service-override 25.1.2 → 26.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-files-service-override",
-  "version": "25.1.2",
+  "version": "26.0.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": "25.1.2"
+    "@codingame/monaco-vscode-api": "26.0.0"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js

@@ -15,7 +15,7 @@ const ERR_FILE_IS_DIR = createFileSystemProviderError(( localize(1908, "File is
 const ERR_FILE_NOT_DIR = createFileSystemProviderError(( localize(1909, "File is not a directory")), FileSystemProviderErrorCode.FileNotADirectory);
 const ERR_DIR_NOT_EMPTY = createFileSystemProviderError(( localize(1910, "Directory is not empty")), FileSystemProviderErrorCode.Unknown);
 const ERR_FILE_EXCEEDS_STORAGE_QUOTA = createFileSystemProviderError(( localize(1911, "File exceeds available storage quota")), FileSystemProviderErrorCode.FileExceedsStorageQuota);
-const ERR_UNKNOWN_INTERNAL = (message) => createFileSystemProviderError(( localize(
+const ERR_UNKNOWN_INTERNAL = message => createFileSystemProviderError(( localize(
     1912,
     "Internal error occurred in IndexedDB File System Provider. ({0})",
     message
@@ -26,14 +26,16 @@ class IndexedDBFileSystemNode {
         this.type = entry.type;
     }
     read(path) {
-        return this.doRead(path.split('/').filter(p => p.length));
+        return this.doRead(path.split("/").filter(p => p.length));
     }
     doRead(pathParts) {
         if (pathParts.length === 0) {
             return this.entry;
         }
         if (this.entry.type !== FileType.Directory) {
-            throw ERR_UNKNOWN_INTERNAL('Internal error reading from IndexedDBFSNode -- expected directory at ' + this.entry.path);
+            throw ERR_UNKNOWN_INTERNAL(
+                "Internal error reading from IndexedDBFSNode -- expected directory at " + this.entry.path
+            );
         }
         const next = this.entry.children.get(pathParts[0]);
         if (!next) {
@@ -42,90 +44,99 @@ class IndexedDBFileSystemNode {
         return next.doRead(pathParts.slice(1));
     }
     delete(path) {
-        const toDelete = path.split('/').filter(p => p.length);
+        const toDelete = path.split("/").filter(p => p.length);
         if (toDelete.length === 0) {
             if (this.entry.type !== FileType.Directory) {
-                throw ERR_UNKNOWN_INTERNAL(`Internal error deleting from IndexedDBFSNode. Expected root entry to be directory`);
+                throw ERR_UNKNOWN_INTERNAL(
+                    `Internal error deleting from IndexedDBFSNode. Expected root entry to be directory`
+                );
             }
             this.entry.children.clear();
-        }
-        else {
+        } else {
             return this.doDelete(toDelete, path);
         }
     }
     doDelete(pathParts, originalPath) {
         if (pathParts.length === 0) {
-            throw ERR_UNKNOWN_INTERNAL(`Internal error deleting from IndexedDBFSNode -- got no deletion path parts (encountered while deleting ${originalPath})`);
-        }
-        else if (this.entry.type !== FileType.Directory) {
-            throw ERR_UNKNOWN_INTERNAL('Internal error deleting from IndexedDBFSNode -- expected directory at ' + this.entry.path);
-        }
-        else if (pathParts.length === 1) {
+            throw ERR_UNKNOWN_INTERNAL(
+                `Internal error deleting from IndexedDBFSNode -- got no deletion path parts (encountered while deleting ${originalPath})`
+            );
+        } else if (this.entry.type !== FileType.Directory) {
+            throw ERR_UNKNOWN_INTERNAL(
+                "Internal error deleting from IndexedDBFSNode -- expected directory at " + this.entry.path
+            );
+        } else if (pathParts.length === 1) {
             this.entry.children.delete(pathParts[0]);
-        }
-        else {
+        } else {
             const next = this.entry.children.get(pathParts[0]);
             if (!next) {
-                throw ERR_UNKNOWN_INTERNAL('Internal error deleting from IndexedDBFSNode -- expected entry at ' + this.entry.path + '/' + next);
+                throw ERR_UNKNOWN_INTERNAL(
+                    "Internal error deleting from IndexedDBFSNode -- expected entry at " + this.entry.path + "/" + next
+                );
             }
             next.doDelete(pathParts.slice(1), originalPath);
         }
     }
     add(path, entry) {
-        this.doAdd(path.split('/').filter(p => p.length), entry, path);
+        this.doAdd(path.split("/").filter(p => p.length), entry, path);
     }
     doAdd(pathParts, entry, originalPath) {
         if (pathParts.length === 0) {
-            throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- adding empty path (encountered while adding ${originalPath})`);
-        }
-        else if (this.entry.type !== FileType.Directory) {
-            throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- parent is not a directory (encountered while adding ${originalPath})`);
-        }
-        else if (pathParts.length === 1) {
+            throw ERR_UNKNOWN_INTERNAL(
+                `Internal error creating IndexedDBFSNode -- adding empty path (encountered while adding ${originalPath})`
+            );
+        } else if (this.entry.type !== FileType.Directory) {
+            throw ERR_UNKNOWN_INTERNAL(
+                `Internal error creating IndexedDBFSNode -- parent is not a directory (encountered while adding ${originalPath})`
+            );
+        } else if (pathParts.length === 1) {
             const next = pathParts[0];
             const existing = this.entry.children.get(next);
-            if (entry.type === 'dir') {
+            if (entry.type === "dir") {
                 if (existing?.entry.type === FileType.File) {
-                    throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- overwriting file with directory: ${this.entry.path}/${next} (encountered while adding ${originalPath})`);
+                    throw ERR_UNKNOWN_INTERNAL(
+                        `Internal error creating IndexedDBFSNode -- overwriting file with directory: ${this.entry.path}/${next} (encountered while adding ${originalPath})`
+                    );
                 }
                 this.entry.children.set(next, existing ?? ( new IndexedDBFileSystemNode({
                     type: FileType.Directory,
-                    path: this.entry.path + '/' + next,
-                    children: ( new Map()),
+                    path: this.entry.path + "/" + next,
+                    children: ( new Map())
                 })));
-            }
-            else {
+            } else {
                 if (existing?.entry.type === FileType.Directory) {
-                    throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- overwriting directory with file: ${this.entry.path}/${next} (encountered while adding ${originalPath})`);
+                    throw ERR_UNKNOWN_INTERNAL(
+                        `Internal error creating IndexedDBFSNode -- overwriting directory with file: ${this.entry.path}/${next} (encountered while adding ${originalPath})`
+                    );
                 }
                 this.entry.children.set(next, ( new IndexedDBFileSystemNode({
                     type: FileType.File,
-                    path: this.entry.path + '/' + next,
-                    size: entry.size,
+                    path: this.entry.path + "/" + next,
+                    size: entry.size
                 })));
             }
-        }
-        else if (pathParts.length > 1) {
+        } else if (pathParts.length > 1) {
             const next = pathParts[0];
             let childNode = this.entry.children.get(next);
             if (!childNode) {
                 childNode = ( new IndexedDBFileSystemNode({
                     children: ( new Map()),
-                    path: this.entry.path + '/' + next,
+                    path: this.entry.path + "/" + next,
                     type: FileType.Directory
                 }));
                 this.entry.children.set(next, childNode);
-            }
-            else if (childNode.type === FileType.File) {
-                throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- overwriting file entry with directory: ${this.entry.path}/${next} (encountered while adding ${originalPath})`);
+            } else if (childNode.type === FileType.File) {
+                throw ERR_UNKNOWN_INTERNAL(
+                    `Internal error creating IndexedDBFSNode -- overwriting file entry with directory: ${this.entry.path}/${next} (encountered while adding ${originalPath})`
+                );
             }
             childNode.doAdd(pathParts.slice(1), entry, originalPath);
         }
     }
-    print(indentation = '') {
+    print(indentation = "") {
         console.log(indentation + this.entry.path);
         if (this.entry.type === FileType.Directory) {
-            this.entry.children.forEach(child => child.print(indentation + ' '));
+            this.entry.children.forEach(child => child.print(indentation + " "));
         }
     }
 }
@@ -135,8 +146,7 @@ class IndexedDBFileSystemProvider extends Disposable {
         this.scheme = scheme;
         this.indexedDB = indexedDB;
         this.store = store;
-        this.capabilities = FileSystemProviderCapabilities.FileReadWrite
-            | FileSystemProviderCapabilities.PathCaseSensitive;
+        this.capabilities = FileSystemProviderCapabilities.FileReadWrite | FileSystemProviderCapabilities.FileAppend | FileSystemProviderCapabilities.PathCaseSensitive;
         this.onDidChangeCapabilities = Event.None;
         this.extUri = ( new ExtUri(() => false)) ;
         this._onDidChangeFile = this._register(( new Emitter()));
@@ -147,7 +157,10 @@ class IndexedDBFileSystemProvider extends Disposable {
         if (watchCrossWindowChanges) {
             this.changesBroadcastChannel = this._register(( new BroadcastDataChannel(`vscode.indexedDB.${scheme}.changes`)));
             this._register(this.changesBroadcastChannel.onDidReceiveData(changes => {
-                this._onDidChangeFile.fire(( changes.map(c => ({ type: c.type, resource: URI.revive(c.resource) }))));
+                this._onDidChangeFile.fire(( changes.map(c => ({
+                    type: c.type,
+                    resource: URI.revive(c.resource)
+                }))));
             }));
         }
     }
@@ -160,9 +173,10 @@ class IndexedDBFileSystemProvider extends Disposable {
             if (resourceStat.type === FileType.File) {
                 throw ERR_FILE_NOT_DIR;
             }
-        }
-        catch (error) {  }
-        (await this.getFiletree()).add(resource.path, { type: 'dir' });
+        } catch (error) {}
+        (await this.getFiletree()).add(resource.path, {
+            type: "dir"
+        });
     }
     async stat(resource) {
         const entry = (await this.getFiletree()).read(resource.path);
@@ -191,13 +205,12 @@ class IndexedDBFileSystemProvider extends Disposable {
         }
         if (entry.type !== FileType.Directory) {
             throw ERR_FILE_NOT_DIR;
-        }
-        else {
+        } else {
             return ( [...entry.children.entries()].map(([name, node]) => [name, node.type]));
         }
     }
     async readFile(resource) {
-        const result = await this.indexedDB.runInTransaction(this.store, 'readonly', objectStore => objectStore.get(resource.path));
+        const result = await this.indexedDB.runInTransaction(this.store, "readonly", objectStore => objectStore.get(resource.path));
         if (result === undefined) {
             throw ERR_FILE_NOT_FOUND;
         }
@@ -206,7 +219,10 @@ class IndexedDBFileSystemProvider extends Disposable {
             throw ERR_UNKNOWN_INTERNAL(`IndexedDB entry at "${resource.path}" in unexpected format`);
         }
         const fileTree = await this.getFiletree();
-        fileTree.add(resource.path, { type: 'file', size: buffer.byteLength });
+        fileTree.add(resource.path, {
+            type: "file",
+            size: buffer.byteLength
+        });
         return buffer;
     }
     async writeFile(resource, content, opts) {
@@ -214,7 +230,15 @@ class IndexedDBFileSystemProvider extends Disposable {
         if (existing?.type === FileType.Directory) {
             throw ERR_FILE_IS_DIR;
         }
-        await this.bulkWrite([[resource, content]]);
+        let finalContent = content;
+        if (opts.append && existing) {
+            const existingContent = await this.readFile(resource);
+            const combined = ( new Uint8Array(existingContent.byteLength + content.byteLength));
+            combined.set(existingContent, 0);
+            combined.set(content, existingContent.byteLength);
+            finalContent = combined;
+        }
+        await this.bulkWrite([[resource, finalContent]]);
     }
     async rename(from, to, opts) {
         const fileTree = await this.getFiletree();
@@ -225,27 +249,37 @@ class IndexedDBFileSystemProvider extends Disposable {
         const toEntry = fileTree.read(to.path);
         if (toEntry) {
             if (!opts.overwrite) {
-                throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+                throw createFileSystemProviderError("file exists already", FileSystemProviderErrorCode.FileExists);
             }
             if (toEntry.type !== fromEntry.type) {
-                throw createFileSystemProviderError('Cannot rename files with different types', FileSystemProviderErrorCode.Unknown);
+                throw createFileSystemProviderError(
+                    "Cannot rename files with different types",
+                    FileSystemProviderErrorCode.Unknown
+                );
             }
-            await this.delete(to, { recursive: true, useTrash: false, atomic: false });
-        }
-        const toTargetResource = (path) => this.extUri.joinPath(to, this.extUri.relativePath(from, from.with({ path })) || '');
+            await this.delete(to, {
+                recursive: true,
+                useTrash: false,
+                atomic: false
+            });
+        }
+        const toTargetResource = path => this.extUri.joinPath(to, this.extUri.relativePath(from, from.with({
+            path
+        })) || "");
         const sourceEntries = await this.tree(from);
         const sourceFiles = [];
         for (const sourceEntry of sourceEntries) {
             if (sourceEntry[1] === FileType.File) {
                 sourceFiles.push(sourceEntry);
-            }
-            else if (sourceEntry[1] === FileType.Directory) {
-                fileTree.add(toTargetResource(sourceEntry[0]).path, { type: 'dir' });
+            } else if (sourceEntry[1] === FileType.Directory) {
+                fileTree.add(toTargetResource(sourceEntry[0]).path, {
+                    type: "dir"
+                });
             }
         }
         if (sourceFiles.length) {
             const targetFiles = [];
-            const sourceFilesContents = await this.indexedDB.runInTransaction(this.store, 'readonly', objectStore => ( sourceFiles.map(([path]) => objectStore.get(path))));
+            const sourceFilesContents = await this.indexedDB.runInTransaction(this.store, "readonly", objectStore => ( sourceFiles.map(([path]) => objectStore.get(path))));
             for (let index = 0; index < sourceFiles.length; index++) {
                 const content = sourceFilesContents[index] instanceof Uint8Array ? sourceFilesContents[index] : isString(sourceFilesContents[index]) ? VSBuffer.fromString(sourceFilesContents[index]).buffer : undefined;
                 if (content) {
@@ -254,14 +288,17 @@ class IndexedDBFileSystemProvider extends Disposable {
             }
             await this.bulkWrite(targetFiles);
         }
-        await this.delete(from, { recursive: true, useTrash: false, atomic: false });
+        await this.delete(from, {
+            recursive: true,
+            useTrash: false,
+            atomic: false
+        });
     }
     async delete(resource, opts) {
         let stat;
         try {
             stat = await this.stat(resource);
-        }
-        catch (e) {
+        } catch (e) {
             if (e.code === FileSystemProviderErrorCode.FileNotFound) {
                 return;
             }
@@ -271,8 +308,7 @@ class IndexedDBFileSystemProvider extends Disposable {
         if (opts.recursive) {
             const tree = await this.tree(resource);
             toDelete = ( tree.map(([path]) => path));
-        }
-        else {
+        } else {
             if (stat.type === FileType.Directory && (await this.readdir(resource)).length) {
                 throw ERR_DIR_NOT_EMPTY;
             }
@@ -281,9 +317,12 @@ class IndexedDBFileSystemProvider extends Disposable {
         await this.deleteKeys(toDelete);
         (await this.getFiletree()).delete(resource.path);
         toDelete.forEach(key => this.mtimes.delete(key));
-        this.triggerChanges(( toDelete.map(
-            path => ({ resource: resource.with({ path }), type: FileChangeType.DELETED })
-        )));
+        this.triggerChanges(( toDelete.map(path => ({
+            resource: resource.with({
+                path
+            }),
+            type: FileChangeType.DELETED
+        }))));
     }
     async tree(resource) {
         const stat = await this.stat(resource);
@@ -312,37 +351,47 @@ class IndexedDBFileSystemProvider extends Disposable {
             this.cachedFiletree = (async () => {
                 const rootNode = ( new IndexedDBFileSystemNode({
                     children: ( new Map()),
-                    path: '',
+                    path: "",
                     type: FileType.Directory
                 }));
-                const result = await this.indexedDB.runInTransaction(this.store, 'readonly', objectStore => objectStore.getAllKeys());
+                const result = await this.indexedDB.runInTransaction(this.store, "readonly", objectStore => objectStore.getAllKeys());
                 const keys = ( result.map(key => ( key.toString())));
-                keys.forEach(key => rootNode.add(key, { type: 'file' }));
+                keys.forEach(key => rootNode.add(key, {
+                    type: "file"
+                }));
                 return rootNode;
             })();
         }
         return this.cachedFiletree;
     }
     async bulkWrite(files) {
-        files.forEach(([resource, content]) => this.fileWriteBatch.push({ content, resource }));
+        files.forEach(([resource, content]) => this.fileWriteBatch.push({
+            content,
+            resource
+        }));
         await this.writeManyThrottler.queue(() => this.writeMany());
         const fileTree = await this.getFiletree();
         for (const [resource, content] of files) {
-            fileTree.add(resource.path, { type: 'file', size: content.byteLength });
+            fileTree.add(resource.path, {
+                type: "file",
+                size: content.byteLength
+            });
             this.mtimes.set(( resource.toString()), Date.now());
         }
-        this.triggerChanges(( files.map(([resource]) => ({ resource, type: FileChangeType.UPDATED }))));
+        this.triggerChanges(( files.map(([resource]) => ({
+            resource,
+            type: FileChangeType.UPDATED
+        }))));
     }
     async writeMany() {
         if (this.fileWriteBatch.length) {
             const fileBatch = this.fileWriteBatch.splice(0, this.fileWriteBatch.length);
             try {
-                await this.indexedDB.runInTransaction(this.store, 'readwrite', objectStore => ( fileBatch.map(entry => {
+                await this.indexedDB.runInTransaction(this.store, "readwrite", objectStore => ( fileBatch.map(entry => {
                     return objectStore.put(entry.content, entry.resource.path);
                 })));
-            }
-            catch (ex) {
-                if (ex instanceof DOMException && ex.name === 'QuotaExceededError') {
+            } catch (ex) {
+                if (ex instanceof DOMException && ex.name === "QuotaExceededError") {
                     throw ERR_FILE_EXCEEDS_STORAGE_QUOTA;
                 }
                 throw ex;
@@ -351,11 +400,11 @@ class IndexedDBFileSystemProvider extends Disposable {
     }
     async deleteKeys(keys) {
         if (keys.length) {
-            await this.indexedDB.runInTransaction(this.store, 'readwrite', objectStore => ( keys.map(key => objectStore.delete(key))));
+            await this.indexedDB.runInTransaction(this.store, "readwrite", objectStore => ( keys.map(key => objectStore.delete(key))));
         }
     }
     async reset() {
-        await this.indexedDB.runInTransaction(this.store, 'readwrite', objectStore => objectStore.clear());
+        await this.indexedDB.runInTransaction(this.store, "readwrite", objectStore => objectStore.clear());
     }
 }