@codingame/monaco-vscode-files-service-override 4.0.0 → 4.1.0

package/files.js

@@ -1,6 +1,6 @@
 import { __decorate, __param } from './external/tslib/tslib.es6.js';
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { FileService } from './vscode/src/vs/platform/files/common/fileService.js';
+import { FileService } from 'vscode/vscode/vs/platform/files/common/fileService';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
 import { InMemoryFileSystemProvider } from 'vscode/vscode/vs/platform/files/common/inMemoryFilesystemProvider';
 export { InMemoryFileSystemProvider } from 'vscode/vscode/vs/platform/files/common/inMemoryFilesystemProvider';
@@ -12,14 +12,15 @@ import { extUri, joinPath } from 'vscode/vscode/vs/base/common/resources';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
 export { HTMLFileSystemProvider } from 'vscode/vscode/vs/platform/files/browser/htmlFileSystemProvider';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { IndexedDBFileSystemProvider } from './vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js';
+import { IndexedDBFileSystemProvider } from 'vscode/vscode/vs/platform/files/browser/indexedDBFileSystemProvider';
+export { IndexedDBFileSystemProvider } from 'vscode/vscode/vs/platform/files/browser/indexedDBFileSystemProvider';
 import { IndexedDB } from 'vscode/vscode/vs/base/browser/indexedDB';
 export { IndexedDB } from 'vscode/vscode/vs/base/browser/indexedDB';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
 import { BufferLogger } from 'vscode/vscode/vs/platform/log/common/bufferLog';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
-import { BrowserTextFileService } from './vscode/src/vs/workbench/services/textfile/browser/browserTextFileService.js';
+import { BrowserTextFileService } from 'vscode/vscode/vs/workbench/services/textfile/browser/browserTextFileService';
 import { IFilesConfigurationService, FilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
 import { BrowserElevatedFileService } from './vscode/src/vs/workbench/services/files/browser/elevatedFileService.js';
 import { IElevatedFileService } from 'vscode/vscode/vs/workbench/services/files/common/elevatedFileService';
@@ -525,4 +526,4 @@ function registerFileSystemOverlay(priority, provider) {
     return fileSystemProvider.register(priority, provider);
 }
 
-export { CustomSchemas, DelegateFileSystemProvider, IndexedDBFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, createIndexedDBProviders, getServiceOverride as default, initFile, registerCustomProvider, registerExtensionFile, registerFileSystemOverlay };
+export { CustomSchemas, DelegateFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, createIndexedDBProviders, getServiceOverride as default, initFile, registerCustomProvider, registerExtensionFile, registerFileSystemOverlay };

package/index.js

@@ -3,4 +3,4 @@ export { FileChangeType, FilePermission, FileSystemProviderCapabilities, FileSys
 export { HTMLFileSystemProvider } from 'vscode/vscode/vs/platform/files/browser/htmlFileSystemProvider';
 export { InMemoryFileSystemProvider } from 'vscode/vscode/vs/platform/files/common/inMemoryFilesystemProvider';
 export { IndexedDB } from 'vscode/vscode/vs/base/browser/indexedDB';
-export { IndexedDBFileSystemProvider } from './vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js';
+export { IndexedDBFileSystemProvider } from 'vscode/vscode/vs/platform/files/browser/indexedDBFileSystemProvider';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-files-service-override",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,6 +18,6 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.0.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.1.0"
   }
 }

package/override/vs/platform/dialogs/common/dialogs.js

@@ -1,10 +0,0 @@
-export { AbstractDialogHandler, IDialogService, IFileDialogService, getFileNamesMessage } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
-
-var ConfirmResult;
-( (function(ConfirmResult) {
-    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
-    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
-    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
-})(ConfirmResult || (ConfirmResult = {})));
-
-export { ConfirmResult };

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

@@ -1,406 +0,0 @@
-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 };