@codingame/monaco-vscode-files-service-override 1.83.7 → 1.83.9

package/vscode/src/vs/platform/files/common/files.js

@@ -0,0 +1,134 @@
+import { isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+
+var FileType;
+( (function(FileType) {
+    FileType[FileType["Unknown"] = 0] = "Unknown";
+    FileType[FileType["File"] = 1] = "File";
+    FileType[FileType["Directory"] = 2] = "Directory";
+    FileType[FileType["SymbolicLink"] = 64] = "SymbolicLink";
+})(FileType || (FileType = {})));
+var FilePermission;
+( (function(FilePermission) {
+    FilePermission[FilePermission["Readonly"] = 1] = "Readonly";
+    FilePermission[FilePermission["Locked"] = 2] = "Locked";
+})(FilePermission || (FilePermission = {})));
+var FileSystemProviderCapabilities;
+( (function(FileSystemProviderCapabilities) {
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["None"] = 0] = "None";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileReadWrite"] = 2] = "FileReadWrite";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileOpenReadWriteClose"] = 4] = "FileOpenReadWriteClose";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileReadStream"] = 16] = "FileReadStream";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileFolderCopy"] = 8] = "FileFolderCopy";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["PathCaseSensitive"] = 1024] = "PathCaseSensitive";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["Readonly"] = 2048] = "Readonly";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["Trash"] = 4096] = "Trash";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileWriteUnlock"] = 8192] = "FileWriteUnlock";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileAtomicRead"] = 16384] = "FileAtomicRead";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileAtomicWrite"] = 32768] = "FileAtomicWrite";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileAtomicDelete"] = 65536] = "FileAtomicDelete";
+    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileClone"] = 131072] = "FileClone";
+})(FileSystemProviderCapabilities || (FileSystemProviderCapabilities = {})));
+var FileSystemProviderErrorCode;
+( (function(FileSystemProviderErrorCode) {
+    FileSystemProviderErrorCode["FileExists"] = "EntryExists";
+    FileSystemProviderErrorCode["FileNotFound"] = "EntryNotFound";
+    FileSystemProviderErrorCode["FileNotADirectory"] = "EntryNotADirectory";
+    FileSystemProviderErrorCode["FileIsADirectory"] = "EntryIsADirectory";
+    FileSystemProviderErrorCode["FileExceedsStorageQuota"] = "EntryExceedsStorageQuota";
+    FileSystemProviderErrorCode["FileTooLarge"] = "EntryTooLarge";
+    FileSystemProviderErrorCode["FileWriteLocked"] = "EntryWriteLocked";
+    FileSystemProviderErrorCode["NoPermissions"] = "NoPermissions";
+    FileSystemProviderErrorCode["Unavailable"] = "Unavailable";
+    FileSystemProviderErrorCode["Unknown"] = "Unknown";
+})(FileSystemProviderErrorCode || (FileSystemProviderErrorCode = {})));
+class FileSystemProviderError extends Error {
+    static create(error, code) {
+        const providerError = ( new FileSystemProviderError(( error.toString()), code));
+        markAsFileSystemProviderError(providerError, code);
+        return providerError;
+    }
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+function markAsFileSystemProviderError(error, code) {
+    error.name = code ? `${code} (FileSystemError)` : `FileSystemError`;
+    return error;
+}
+function toFileSystemProviderErrorCode(error) {
+    if (!error) {
+        return FileSystemProviderErrorCode.Unknown;
+    }
+    if (error instanceof FileSystemProviderError) {
+        return error.code;
+    }
+    const match = /^(.+) \(FileSystemError\)$/.exec(error.name);
+    if (!match) {
+        return FileSystemProviderErrorCode.Unknown;
+    }
+    switch (match[1]) {
+        case FileSystemProviderErrorCode.FileExists: return FileSystemProviderErrorCode.FileExists;
+        case FileSystemProviderErrorCode.FileIsADirectory: return FileSystemProviderErrorCode.FileIsADirectory;
+        case FileSystemProviderErrorCode.FileNotADirectory: return FileSystemProviderErrorCode.FileNotADirectory;
+        case FileSystemProviderErrorCode.FileNotFound: return FileSystemProviderErrorCode.FileNotFound;
+        case FileSystemProviderErrorCode.FileTooLarge: return FileSystemProviderErrorCode.FileTooLarge;
+        case FileSystemProviderErrorCode.FileWriteLocked: return FileSystemProviderErrorCode.FileWriteLocked;
+        case FileSystemProviderErrorCode.NoPermissions: return FileSystemProviderErrorCode.NoPermissions;
+        case FileSystemProviderErrorCode.Unavailable: return FileSystemProviderErrorCode.Unavailable;
+    }
+    return FileSystemProviderErrorCode.Unknown;
+}
+var FileChangeType;
+( (function(FileChangeType) {
+    FileChangeType[FileChangeType["UPDATED"] = 0] = "UPDATED";
+    FileChangeType[FileChangeType["ADDED"] = 1] = "ADDED";
+    FileChangeType[FileChangeType["DELETED"] = 2] = "DELETED";
+})(FileChangeType || (FileChangeType = {})));
+class ByteSize {
+    static { this.KB = 1024; }
+    static { this.MB = ByteSize.KB * ByteSize.KB; }
+    static { this.GB = ByteSize.MB * ByteSize.KB; }
+    static { this.TB = ByteSize.GB * ByteSize.KB; }
+    static formatSize(size) {
+        if (!isNumber(size)) {
+            size = 0;
+        }
+        if (size < ByteSize.KB) {
+            return ( localizeWithPath('vs/platform/files/common/files', 'sizeB', "{0}B", size.toFixed(0)));
+        }
+        if (size < ByteSize.MB) {
+            return ( localizeWithPath(
+                'vs/platform/files/common/files',
+                'sizeKB',
+                "{0}KB",
+                (size / ByteSize.KB).toFixed(2)
+            ));
+        }
+        if (size < ByteSize.GB) {
+            return ( localizeWithPath(
+                'vs/platform/files/common/files',
+                'sizeMB',
+                "{0}MB",
+                (size / ByteSize.MB).toFixed(2)
+            ));
+        }
+        if (size < ByteSize.TB) {
+            return ( localizeWithPath(
+                'vs/platform/files/common/files',
+                'sizeGB',
+                "{0}GB",
+                (size / ByteSize.GB).toFixed(2)
+            ));
+        }
+        return ( localizeWithPath(
+            'vs/platform/files/common/files',
+            'sizeTB',
+            "{0}TB",
+            (size / ByteSize.TB).toFixed(2)
+        ));
+    }
+}
+
+export { ByteSize, FileChangeType, FilePermission, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, FileType, markAsFileSystemProviderError, toFileSystemProviderErrorCode };

package/vscode/src/vs/platform/files/common/inMemoryFilesystemProvider.js

@@ -0,0 +1,222 @@
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { newWriteableStream } from 'monaco-editor/esm/vs/base/common/stream.js';
+import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+
+class File {
+    constructor(name) {
+        this.type = FileType.File;
+        this.ctime = Date.now();
+        this.mtime = Date.now();
+        this.size = 0;
+        this.name = name;
+    }
+}
+class Directory {
+    constructor(name) {
+        this.type = FileType.Directory;
+        this.ctime = Date.now();
+        this.mtime = Date.now();
+        this.size = 0;
+        this.name = name;
+        this.entries = ( new Map());
+    }
+}
+class InMemoryFileSystemProvider extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.memoryFdCounter = 0;
+        this.fdMemory = ( new Map());
+        this._onDidChangeCapabilities = this._register(( new Emitter()));
+        this.onDidChangeCapabilities = this._onDidChangeCapabilities.event;
+        this._capabilities = 2  | 1024 ;
+        this.root = ( new Directory(''));
+        this._onDidChangeFile = this._register(( new Emitter()));
+        this.onDidChangeFile = this._onDidChangeFile.event;
+        this._bufferedChanges = [];
+    }
+    get capabilities() { return this._capabilities; }
+    setReadOnly(readonly) {
+        const isReadonly = !!((this._capabilities & 2048) );
+        if (readonly !== isReadonly) {
+            this._capabilities = readonly ? 2048  | 1024  | 2
+                : 2  | 1024 ;
+            this._onDidChangeCapabilities.fire();
+        }
+    }
+    async stat(resource) {
+        return this._lookup(resource, false);
+    }
+    async readdir(resource) {
+        const entry = this._lookupAsDirectory(resource, false);
+        const result = [];
+        entry.entries.forEach((child, name) => result.push([name, child.type]));
+        return result;
+    }
+    async readFile(resource) {
+        const data = this._lookupAsFile(resource, false).data;
+        if (data) {
+            return data;
+        }
+        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    readFileStream(resource) {
+        const data = this._lookupAsFile(resource, false).data;
+        const stream = newWriteableStream(data => VSBuffer.concat(( data.map(data => VSBuffer.wrap(data)))).buffer);
+        stream.end(data);
+        return stream;
+    }
+    async writeFile(resource, content, opts) {
+        const basename = resources.basename(resource);
+        const parent = this._lookupParentDirectory(resource);
+        let entry = parent.entries.get(basename);
+        if (entry instanceof Directory) {
+            throw createFileSystemProviderError('file is directory', FileSystemProviderErrorCode.FileIsADirectory);
+        }
+        if (!entry && !opts.create) {
+            throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+        }
+        if (entry && opts.create && !opts.overwrite) {
+            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+        }
+        if (!entry) {
+            entry = ( new File(basename));
+            parent.entries.set(basename, entry);
+            this._fireSoon({ type: 1 , resource });
+        }
+        entry.mtime = Date.now();
+        entry.size = content.byteLength;
+        entry.data = content;
+        this._fireSoon({ type: 0 , resource });
+    }
+    open(resource, opts) {
+        const data = this._lookupAsFile(resource, false).data;
+        if (data) {
+            const fd = this.memoryFdCounter++;
+            this.fdMemory.set(fd, data);
+            return Promise.resolve(fd);
+        }
+        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    close(fd) {
+        this.fdMemory.delete(fd);
+        return Promise.resolve();
+    }
+    read(fd, pos, data, offset, length) {
+        const memory = this.fdMemory.get(fd);
+        if (!memory) {
+            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
+        }
+        const toWrite = VSBuffer.wrap(memory).slice(pos, pos + length);
+        data.set(toWrite.buffer, offset);
+        return Promise.resolve(toWrite.byteLength);
+    }
+    write(fd, pos, data, offset, length) {
+        const memory = this.fdMemory.get(fd);
+        if (!memory) {
+            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
+        }
+        const toWrite = VSBuffer.wrap(data).slice(offset, offset + length);
+        memory.set(toWrite.buffer, pos);
+        return Promise.resolve(toWrite.byteLength);
+    }
+    async rename(from, to, opts) {
+        if (!opts.overwrite && this._lookup(to, true)) {
+            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+        }
+        const entry = this._lookup(from, false);
+        const oldParent = this._lookupParentDirectory(from);
+        const newParent = this._lookupParentDirectory(to);
+        const newName = resources.basename(to);
+        oldParent.entries.delete(entry.name);
+        entry.name = newName;
+        newParent.entries.set(newName, entry);
+        this._fireSoon({ type: 2 , resource: from }, { type: 1 , resource: to });
+    }
+    async delete(resource, opts) {
+        const dirname = resources.dirname(resource);
+        const basename = resources.basename(resource);
+        const parent = this._lookupAsDirectory(dirname, false);
+        if (( parent.entries.has(basename))) {
+            parent.entries.delete(basename);
+            parent.mtime = Date.now();
+            parent.size -= 1;
+            this._fireSoon({ type: 0 , resource: dirname }, { resource, type: 2  });
+        }
+    }
+    async mkdir(resource) {
+        if (this._lookup(resource, true)) {
+            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+        }
+        const basename = resources.basename(resource);
+        const dirname = resources.dirname(resource);
+        const parent = this._lookupAsDirectory(dirname, false);
+        const entry = ( new Directory(basename));
+        parent.entries.set(entry.name, entry);
+        parent.mtime = Date.now();
+        parent.size += 1;
+        this._fireSoon({ type: 0 , resource: dirname }, { type: 1 , resource });
+    }
+    _lookup(uri, silent) {
+        const parts = uri.path.split('/');
+        let entry = this.root;
+        for (const part of parts) {
+            if (!part) {
+                continue;
+            }
+            let child;
+            if (entry instanceof Directory) {
+                child = entry.entries.get(part);
+            }
+            if (!child) {
+                if (!silent) {
+                    throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+                }
+                else {
+                    return undefined;
+                }
+            }
+            entry = child;
+        }
+        return entry;
+    }
+    _lookupAsDirectory(uri, silent) {
+        const entry = this._lookup(uri, silent);
+        if (entry instanceof Directory) {
+            return entry;
+        }
+        throw createFileSystemProviderError('file not a directory', FileSystemProviderErrorCode.FileNotADirectory);
+    }
+    _lookupAsFile(uri, silent) {
+        const entry = this._lookup(uri, silent);
+        if (entry instanceof File) {
+            return entry;
+        }
+        throw createFileSystemProviderError('file is a directory', FileSystemProviderErrorCode.FileIsADirectory);
+    }
+    _lookupParentDirectory(uri) {
+        const dirname = resources.dirname(uri);
+        return this._lookupAsDirectory(dirname, false);
+    }
+    watch(resource, opts) {
+        return Disposable.None;
+    }
+    _fireSoon(...changes) {
+        this._bufferedChanges.push(...changes);
+        if (this._fireSoonHandle) {
+            clearTimeout(this._fireSoonHandle);
+        }
+        this._fireSoonHandle = setTimeout(() => {
+            this._onDidChangeFile.fire(this._bufferedChanges);
+            this._bufferedChanges.length = 0;
+        }, 5);
+    }
+    dispose() {
+        super.dispose();
+        this.fdMemory.clear();
+    }
+}
+
+export { InMemoryFileSystemProvider };

package/vscode/src/vs/platform/files/common/io.js

@@ -0,0 +1,77 @@
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { canceled } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { ensureFileSystemProviderError, createFileSystemProviderError, FileSystemProviderErrorCode } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+
+async function readFileIntoStream(provider, resource, target, transformer, options, token) {
+    let error = undefined;
+    try {
+        await doReadFileIntoStream(provider, resource, target, transformer, options, token);
+    }
+    catch (err) {
+        error = err;
+    }
+    finally {
+        if (error && options.errorTransformer) {
+            error = options.errorTransformer(error);
+        }
+        if (typeof error !== 'undefined') {
+            target.error(error);
+        }
+        target.end();
+    }
+}
+async function doReadFileIntoStream(provider, resource, target, transformer, options, token) {
+    throwIfCancelled(token);
+    const handle = await provider.open(resource, { create: false });
+    try {
+        throwIfCancelled(token);
+        let totalBytesRead = 0;
+        let bytesRead = 0;
+        let allowedRemainingBytes = (options && typeof options.length === 'number') ? options.length : undefined;
+        let buffer = VSBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
+        let posInFile = options && typeof options.position === 'number' ? options.position : 0;
+        let posInBuffer = 0;
+        do {
+            bytesRead = await provider.read(handle, posInFile, buffer.buffer, posInBuffer, buffer.byteLength - posInBuffer);
+            posInFile += bytesRead;
+            posInBuffer += bytesRead;
+            totalBytesRead += bytesRead;
+            if (typeof allowedRemainingBytes === 'number') {
+                allowedRemainingBytes -= bytesRead;
+            }
+            if (posInBuffer === buffer.byteLength) {
+                await target.write(transformer(buffer));
+                buffer = VSBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
+                posInBuffer = 0;
+            }
+        } while (bytesRead > 0 && (typeof allowedRemainingBytes !== 'number' || allowedRemainingBytes > 0) && throwIfCancelled(token) && throwIfTooLarge(totalBytesRead, options));
+        if (posInBuffer > 0) {
+            let lastChunkLength = posInBuffer;
+            if (typeof allowedRemainingBytes === 'number') {
+                lastChunkLength = Math.min(posInBuffer, allowedRemainingBytes);
+            }
+            target.write(transformer(buffer.slice(0, lastChunkLength)));
+        }
+    }
+    catch (error) {
+        throw ensureFileSystemProviderError(error);
+    }
+    finally {
+        await provider.close(handle);
+    }
+}
+function throwIfCancelled(token) {
+    if (token.isCancellationRequested) {
+        throw canceled();
+    }
+    return true;
+}
+function throwIfTooLarge(totalBytesRead, options) {
+    if (typeof options?.limits?.size === 'number' && totalBytesRead > options.limits.size) {
+        throw createFileSystemProviderError(localizeWithPath('vs/platform/files/common/io', 'fileTooLargeError', "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
+    }
+    return true;
+}
+
+export { readFileIntoStream };