@codingame/monaco-editor-wrapper 4.0.0-next.3 → 4.0.0

package/dist/node_modules/@codingame/monaco-vscode-files-service-override/vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js

@@ -0,0 +1,406 @@
+import { Throttler } from 'vscode/vscode/vs/base/common/async';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ExtUri } from 'vscode/vscode/vs/base/common/resources';
+import { isString } from 'vscode/vscode/vs/base/common/types';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType, FileSystemProviderError } from 'vscode/vscode/vs/platform/files/common/files';
+import { DBClosedError } from 'vscode/vscode/vs/base/browser/indexedDB';
+import { BroadcastDataChannel } from 'vscode/vscode/vs/base/browser/broadcast';
+
+const ERR_FILE_NOT_FOUND = createFileSystemProviderError(( localizeWithPath(
+    'vs/platform/files/browser/indexedDBFileSystemProvider',
+    'fileNotExists',
+    "File does not exist"
+)), FileSystemProviderErrorCode.FileNotFound);
+const ERR_FILE_IS_DIR = createFileSystemProviderError(( localizeWithPath(
+    'vs/platform/files/browser/indexedDBFileSystemProvider',
+    'fileIsDirectory',
+    "File is Directory"
+)), FileSystemProviderErrorCode.FileIsADirectory);
+const ERR_FILE_NOT_DIR = createFileSystemProviderError(( localizeWithPath(
+    'vs/platform/files/browser/indexedDBFileSystemProvider',
+    'fileNotDirectory',
+    "File is not a directory"
+)), FileSystemProviderErrorCode.FileNotADirectory);
+const ERR_DIR_NOT_EMPTY = createFileSystemProviderError(( localizeWithPath(
+    'vs/platform/files/browser/indexedDBFileSystemProvider',
+    'dirIsNotEmpty',
+    "Directory is not empty"
+)), FileSystemProviderErrorCode.Unknown);
+const ERR_FILE_EXCEEDS_STORAGE_QUOTA = createFileSystemProviderError(( localizeWithPath(
+    'vs/platform/files/browser/indexedDBFileSystemProvider',
+    'fileExceedsStorageQuota',
+    "File exceeds available storage quota"
+)), FileSystemProviderErrorCode.FileExceedsStorageQuota);
+const ERR_UNKNOWN_INTERNAL = (message) => createFileSystemProviderError(( localizeWithPath(
+    'vs/platform/files/browser/indexedDBFileSystemProvider',
+    'internal',
+    "Internal error occurred in IndexedDB File System Provider. ({0})",
+    message
+)), FileSystemProviderErrorCode.Unknown);
+class IndexedDBFileSystemNode {
+    constructor(entry) {
+        this.entry = entry;
+        this.type = entry.type;
+    }
+    read(path) {
+        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);
+        }
+        const next = this.entry.children.get(pathParts[0]);
+        if (!next) {
+            return undefined;
+        }
+        return next.doRead(pathParts.slice(1));
+    }
+    delete(path) {
+        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`);
+            }
+            this.entry.children.clear();
+        }
+        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) {
+            this.entry.children.delete(pathParts[0]);
+        }
+        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);
+            }
+            next.doDelete(pathParts.slice(1), originalPath);
+        }
+    }
+    add(path, entry) {
+        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) {
+            const next = pathParts[0];
+            const existing = this.entry.children.get(next);
+            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})`);
+                }
+                this.entry.children.set(next, existing ?? ( new IndexedDBFileSystemNode({
+                    type: FileType.Directory,
+                    path: this.entry.path + '/' + next,
+                    children: ( new Map()),
+                })));
+            }
+            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})`);
+                }
+                this.entry.children.set(next, ( new IndexedDBFileSystemNode({
+                    type: FileType.File,
+                    path: this.entry.path + '/' + next,
+                    size: entry.size,
+                })));
+            }
+        }
+        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,
+                    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})`);
+            }
+            childNode.doAdd(pathParts.slice(1), entry, originalPath);
+        }
+    }
+    print(indentation = '') {
+        console.log(indentation + this.entry.path);
+        if (this.entry.type === FileType.Directory) {
+            this.entry.children.forEach(child => child.print(indentation + ' '));
+        }
+    }
+}
+class IndexedDBFileSystemProvider extends Disposable {
+    constructor(scheme, indexedDB, store, watchCrossWindowChanges) {
+        super();
+        this.scheme = scheme;
+        this.indexedDB = indexedDB;
+        this.store = store;
+        this.capabilities = 2
+            | 1024 ;
+        this.onDidChangeCapabilities = Event.None;
+        this.extUri = ( new ExtUri(() => false)) ;
+        this._onDidChangeFile = this._register(( new Emitter()));
+        this.onDidChangeFile = this._onDidChangeFile.event;
+        this._onReportError = this._register(( new Emitter()));
+        this.onReportError = this._onReportError.event;
+        this.mtimes = ( new Map());
+        this.fileWriteBatch = [];
+        this.writeManyThrottler = ( new Throttler());
+        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) }))));
+            }));
+        }
+    }
+    watch(resource, opts) {
+        return Disposable.None;
+    }
+    async mkdir(resource) {
+        try {
+            const resourceStat = await this.stat(resource);
+            if (resourceStat.type === FileType.File) {
+                throw ERR_FILE_NOT_DIR;
+            }
+        }
+        catch (error) {  }
+        (await this.getFiletree()).add(resource.path, { type: 'dir' });
+    }
+    async stat(resource) {
+        const entry = (await this.getFiletree()).read(resource.path);
+        if (entry?.type === FileType.File) {
+            return {
+                type: FileType.File,
+                ctime: 0,
+                mtime: this.mtimes.get(( resource.toString())) || 0,
+                size: entry.size ?? (await this.readFile(resource)).byteLength
+            };
+        }
+        if (entry?.type === FileType.Directory) {
+            return {
+                type: FileType.Directory,
+                ctime: 0,
+                mtime: 0,
+                size: 0
+            };
+        }
+        throw ERR_FILE_NOT_FOUND;
+    }
+    async readdir(resource) {
+        try {
+            const entry = (await this.getFiletree()).read(resource.path);
+            if (!entry) {
+                return [];
+            }
+            if (entry.type !== FileType.Directory) {
+                throw ERR_FILE_NOT_DIR;
+            }
+            else {
+                return ( [...entry.children.entries()].map(([name, node]) => [name, node.type]));
+            }
+        }
+        catch (error) {
+            this.reportError('readDir', error);
+            throw error;
+        }
+    }
+    async readFile(resource) {
+        try {
+            const result = await this.indexedDB.runInTransaction(this.store, 'readonly', objectStore => objectStore.get(resource.path));
+            if (result === undefined) {
+                throw ERR_FILE_NOT_FOUND;
+            }
+            const buffer = result instanceof Uint8Array ? result : isString(result) ? VSBuffer.fromString(result).buffer : undefined;
+            if (buffer === undefined) {
+                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 });
+            return buffer;
+        }
+        catch (error) {
+            this.reportError('readFile', error);
+            throw error;
+        }
+    }
+    async writeFile(resource, content, opts) {
+        try {
+            const existing = await this.stat(resource).catch(() => undefined);
+            if (existing?.type === FileType.Directory) {
+                throw ERR_FILE_IS_DIR;
+            }
+            await this.bulkWrite([[resource, content]]);
+        }
+        catch (error) {
+            this.reportError('writeFile', error);
+            throw error;
+        }
+    }
+    async rename(from, to, opts) {
+        const fileTree = await this.getFiletree();
+        const fromEntry = fileTree.read(from.path);
+        if (!fromEntry) {
+            throw ERR_FILE_NOT_FOUND;
+        }
+        const toEntry = fileTree.read(to.path);
+        if (toEntry) {
+            if (!opts.overwrite) {
+                throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+            }
+            if (toEntry.type !== fromEntry.type) {
+                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 })) || '');
+        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' });
+            }
+        }
+        if (sourceFiles.length) {
+            const targetFiles = [];
+            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) {
+                    targetFiles.push([toTargetResource(sourceFiles[index][0]), content]);
+                }
+            }
+            await this.bulkWrite(targetFiles);
+        }
+        await this.delete(from, { recursive: true, useTrash: false, atomic: false });
+    }
+    async delete(resource, opts) {
+        let stat;
+        try {
+            stat = await this.stat(resource);
+        }
+        catch (e) {
+            if (e.code === FileSystemProviderErrorCode.FileNotFound) {
+                return;
+            }
+            throw e;
+        }
+        let toDelete;
+        if (opts.recursive) {
+            const tree = await this.tree(resource);
+            toDelete = ( tree.map(([path]) => path));
+        }
+        else {
+            if (stat.type === FileType.Directory && (await this.readdir(resource)).length) {
+                throw ERR_DIR_NOT_EMPTY;
+            }
+            toDelete = [resource.path];
+        }
+        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: 2  })
+        )));
+    }
+    async tree(resource) {
+        const stat = await this.stat(resource);
+        const allEntries = [[resource.path, stat.type]];
+        if (stat.type === FileType.Directory) {
+            const dirEntries = await this.readdir(resource);
+            for (const [key, type] of dirEntries) {
+                const childResource = this.extUri.joinPath(resource, key);
+                allEntries.push([childResource.path, type]);
+                if (type === FileType.Directory) {
+                    const childEntries = await this.tree(childResource);
+                    allEntries.push(...childEntries);
+                }
+            }
+        }
+        return allEntries;
+    }
+    triggerChanges(changes) {
+        if (changes.length) {
+            this._onDidChangeFile.fire(changes);
+            this.changesBroadcastChannel?.postData(changes);
+        }
+    }
+    getFiletree() {
+        if (!this.cachedFiletree) {
+            this.cachedFiletree = (async () => {
+                const rootNode = ( new IndexedDBFileSystemNode({
+                    children: ( new Map()),
+                    path: '',
+                    type: FileType.Directory
+                }));
+                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' }));
+                return rootNode;
+            })();
+        }
+        return this.cachedFiletree;
+    }
+    async bulkWrite(files) {
+        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 });
+            this.mtimes.set(( resource.toString()), Date.now());
+        }
+        this.triggerChanges(( files.map(([resource]) => ({ resource, type: 0  }))));
+    }
+    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 => {
+                    return objectStore.put(entry.content, entry.resource.path);
+                })));
+            }
+            catch (ex) {
+                if (ex instanceof DOMException && ex.name === 'QuotaExceededError') {
+                    throw ERR_FILE_EXCEEDS_STORAGE_QUOTA;
+                }
+                throw ex;
+            }
+        }
+    }
+    async deleteKeys(keys) {
+        if (keys.length) {
+            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());
+    }
+    reportError(operation, error) {
+        this._onReportError.fire({ scheme: this.scheme, operation, code: error instanceof FileSystemProviderError || error instanceof DBClosedError ? error.code : 'unknown' });
+    }
+}
+
+export { IndexedDBFileSystemProvider };