@theia/filesystem 1.55.1 → 1.57.0-next.112

package/package.json

@@ -1,15 +1,14 @@
 {
   "name": "@theia/filesystem",
-  "version": "1.55.1",
+  "version": "1.57.0-next.112+f4778c273",
   "description": "Theia - FileSystem Extension",
   "dependencies": {
-    "@theia/core": "1.55.1",
+    "@theia/core": "1.57.0-next.112+f4778c273",
     "@types/body-parser": "^1.17.0",
     "@types/multer": "^1.4.7",
     "@types/tar-fs": "^1.16.1",
     "async-mutex": "^0.3.1",
     "body-parser": "^1.18.3",
-    "browserfs": "^1.4.3",
     "http-status-codes": "^1.3.0",
     "minimatch": "^5.1.0",
     "multer": "1.4.4-lts.1",
@@ -72,10 +71,10 @@
     "watch": "theiaext watch"
   },
   "devDependencies": {
-    "@theia/ext-scripts": "1.55.1"
+    "@theia/ext-scripts": "1.58.0"
   },
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "be4713a778be16ba831af63a6fbd43b2301e882d"
+  "gitHead": "f4778c2737bb75613f0e1f99da8996bad91f6e17"
 }

package/src/browser/breadcrumbs/filepath-breadcrumbs-container.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { Container, interfaces, injectable, inject } from '@theia/core/shared/inversify';
-import { TreeProps, ContextMenuRenderer, TreeNode, OpenerService, open, NodeProps, defaultTreeProps } from '@theia/core/lib/browser';
+import { TreeProps, ContextMenuRenderer, TreeNode, open, NodeProps, defaultTreeProps } from '@theia/core/lib/browser';
 import { FileTreeModel, FileStatNode, createFileTreeContainer, FileTreeWidget } from '../file-tree';
 
 const BREADCRUMBS_FILETREE_CLASS = 'theia-FilepathBreadcrumbFileTree';
@@ -35,9 +35,6 @@ export function createFileTreeBreadcrumbsWidget(parent: interfaces.Container): B
 @injectable()
 export class BreadcrumbsFileTreeWidget extends FileTreeWidget {
 
-    @inject(OpenerService)
-    protected readonly openerService: OpenerService;
-
     constructor(
         @inject(TreeProps) props: TreeProps,
         @inject(FileTreeModel) override readonly model: FileTreeModel,

package/src/browser/filesystem-frontend-module.ts

@@ -33,6 +33,7 @@ import { FilepathBreadcrumbsContribution } from './breadcrumbs/filepath-breadcru
 import { BreadcrumbsFileTreeWidget, createFileTreeBreadcrumbsWidget } from './breadcrumbs/filepath-breadcrumbs-container';
 import { FilesystemSaveableService } from './filesystem-saveable-service';
 import { SaveableService } from '@theia/core/lib/browser/saveable-service';
+import { VSCodeFileServiceContribution, VSCodeFileSystemProvider } from './vscode-file-service-contribution';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bindFileSystemPreferences(bind);
@@ -46,6 +47,9 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(RemoteFileSystemProvider).toSelf().inSingletonScope();
     bind(RemoteFileServiceContribution).toSelf().inSingletonScope();
     bind(FileServiceContribution).toService(RemoteFileServiceContribution);
+    bind(VSCodeFileSystemProvider).toSelf().inSingletonScope();
+    bind(VSCodeFileServiceContribution).toSelf().inSingletonScope();
+    bind(FileServiceContribution).toService(VSCodeFileServiceContribution);
 
     bind(FileSystemWatcherErrorHandler).toSelf().inSingletonScope();
 

package/src/browser/filesystem-preferences.ts

@@ -95,6 +95,12 @@ export const filesystemPreferenceSchema: PreferenceSchema = {
             description: nls.localizeByDefault('When enabled, will trim trailing whitespace when saving a file.'),
             scope: 'language-overridable'
         },
+        'files.insertFinalNewline': {
+            type: 'boolean',
+            default: false,
+            description: nls.localizeByDefault('When enabled, insert a final new line at the end of the file when saving it.'),
+            scope: 'language-overridable'
+        },
         'files.maxConcurrentUploads': {
             type: 'integer',
             default: 1,
@@ -116,6 +122,7 @@ export interface FileSystemConfiguration {
     'files.participants.timeout': number
     'files.maxFileSizeMB': number
     'files.trimTrailingWhitespace': boolean
+    'files.insertFinalNewline': boolean
     'files.maxConcurrentUploads': number
 }
 

package/src/browser/vscode-file-service-contribution.ts

@@ -0,0 +1,93 @@
+// *****************************************************************************
+// Copyright (C) 2024 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { FileServiceContribution, FileService } from './file-service';
+import {
+    FileChange, FileDeleteOptions, FileOverwriteOptions, FilePermission, FileSystemProvider, FileSystemProviderCapabilities, FileType, FileWriteOptions, Stat, WatchOptions
+} from '../common/files';
+import { Event, URI, Disposable, Emitter } from '@theia/core';
+import { JsonSchemaDataStore } from '@theia/core/lib/browser/json-schema-store';
+import { BinaryBuffer } from '@theia/core/lib/common/buffer';
+
+@injectable()
+export class VSCodeFileSystemProvider implements FileSystemProvider {
+    readonly capabilities = FileSystemProviderCapabilities.Readonly + FileSystemProviderCapabilities.FileReadWrite;
+    readonly onDidChangeCapabilities = Event.None;
+    protected readonly onDidChangeFileEmitter = new Emitter<readonly FileChange[]>();
+    readonly onDidChangeFile = this.onDidChangeFileEmitter.event;
+    readonly onFileWatchError = Event.None;
+
+    @inject(JsonSchemaDataStore)
+    protected readonly store: JsonSchemaDataStore;
+
+    watch(resource: URI, opts: WatchOptions): Disposable {
+        return Disposable.NULL;
+    }
+    async stat(resource: URI): Promise<Stat> {
+        if (this.store.hasSchema(resource)) {
+            const currentTime = Date.now();
+            return {
+                type: FileType.File,
+                permissions: FilePermission.Readonly,
+                mtime: currentTime,
+                ctime: currentTime,
+                size: 0
+            };
+        }
+        throw new Error('Not Found!');
+    }
+    mkdir(resource: URI): Promise<void> {
+        return Promise.resolve();
+    }
+    readdir(resource: URI): Promise<[string, FileType][]> {
+        return Promise.resolve([]);
+    }
+    delete(resource: URI, opts: FileDeleteOptions): Promise<void> {
+        return Promise.resolve();
+    }
+    rename(from: URI, to: URI, opts: FileOverwriteOptions): Promise<void> {
+        return Promise.resolve();
+    }
+    async readFile(resource: URI): Promise<Uint8Array> {
+        if (resource.scheme !== 'vscode') {
+            throw new Error('Not Supported!');
+        }
+        let content: string | undefined;
+        if (resource.authority === 'schemas') {
+            content = this.store.getSchema(resource);
+        }
+        if (typeof content === 'string') {
+            return BinaryBuffer.fromString(content).buffer;
+        }
+        throw new Error('Not Found!');
+    }
+    writeFile(resource: URI, content: Uint8Array, opts: FileWriteOptions): Promise<void> {
+        throw new Error('Not Supported!');
+    }
+}
+
+@injectable()
+export class VSCodeFileServiceContribution implements FileServiceContribution {
+
+    @inject(VSCodeFileSystemProvider)
+    protected readonly provider: VSCodeFileSystemProvider;
+
+    registerFileSystemProviders(service: FileService): void {
+        service.registerProvider('vscode', this.provider);
+    }
+
+}

package/src/browser-only/browser-only-filesystem-frontend-module.ts

@@ -16,19 +16,19 @@
 
 import { ContainerModule } from '@theia/core/shared/inversify';
 import { FileSystemProvider } from '../common/files';
-import { BrowserFSFileSystemProvider } from './browserfs-filesystem-provider';
+import { OPFSFileSystemProvider } from './opfs-filesystem-provider';
 import { RemoteFileSystemProvider, RemoteFileSystemServer } from '../common/remote-file-system-provider';
-import { BrowserFSInitialization, DefaultBrowserFSInitialization } from './browserfs-filesystem-initialization';
+import { OPFSInitialization, DefaultOPFSInitialization } from './opfs-filesystem-initialization';
 import { BrowserOnlyFileSystemProviderServer } from './browser-only-filesystem-provider-server';
 
 export default new ContainerModule((bind, _unbind, isBound, rebind) => {
-    bind(DefaultBrowserFSInitialization).toSelf();
-    bind(BrowserFSFileSystemProvider).toSelf();
-    bind(BrowserFSInitialization).toService(DefaultBrowserFSInitialization);
+    bind(DefaultOPFSInitialization).toSelf();
+    bind(OPFSFileSystemProvider).toSelf();
+    bind(OPFSInitialization).toService(DefaultOPFSInitialization);
     if (isBound(FileSystemProvider)) {
-        rebind(FileSystemProvider).to(BrowserFSFileSystemProvider).inSingletonScope();
+        rebind(FileSystemProvider).to(OPFSFileSystemProvider).inSingletonScope();
     } else {
-        bind(FileSystemProvider).to(BrowserFSFileSystemProvider).inSingletonScope();
+        bind(FileSystemProvider).to(OPFSFileSystemProvider).inSingletonScope();
     }
     if (isBound(RemoteFileSystemProvider)) {
         rebind(RemoteFileSystemServer).to(BrowserOnlyFileSystemProviderServer).inSingletonScope();

package/src/browser-only/opfs-filesystem-initialization.ts

@@ -0,0 +1,36 @@
+// *****************************************************************************
+// Copyright (C) 2023 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import type { OPFSFileSystemProvider } from './opfs-filesystem-provider';
+import { injectable } from '@theia/core/shared/inversify';
+
+export const OPFSInitialization = Symbol('OPFSInitialization');
+export interface OPFSInitialization {
+    getRootDirectory(): Promise<FileSystemDirectoryHandle>
+    initializeFS(provider: OPFSFileSystemProvider): Promise<void>;
+}
+
+@injectable()
+export class DefaultOPFSInitialization implements OPFSInitialization {
+
+    getRootDirectory(): Promise<FileSystemDirectoryHandle> {
+        return navigator.storage.getDirectory();
+    }
+
+    async initializeFS(provider: OPFSFileSystemProvider): Promise<void> {
+
+    }
+}

package/src/browser-only/opfs-filesystem-provider.ts

@@ -0,0 +1,346 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import {
+    FileChange, FileChangeType, FileDeleteOptions,
+    FileOverwriteOptions, FileSystemProviderCapabilities,
+    FileSystemProviderError,
+    FileSystemProviderErrorCode,
+    FileSystemProviderWithFileReadWriteCapability,
+    FileType, FileWriteOptions, Stat, WatchOptions, createFileSystemProviderError
+} from '../common/files';
+import { Emitter, Event, URI, Disposable, Path } from '@theia/core';
+import { OPFSInitialization } from './opfs-filesystem-initialization';
+
+/** Options to be used when traversing the file system handles */
+interface CreateFileSystemHandleOptions {
+    isDirectory?: boolean;
+    create?: boolean;
+}
+
+@injectable()
+export class OPFSFileSystemProvider implements FileSystemProviderWithFileReadWriteCapability {
+    capabilities: FileSystemProviderCapabilities = FileSystemProviderCapabilities.FileReadWrite;
+    onDidChangeCapabilities: Event<void> = Event.None;
+
+    private readonly onDidChangeFileEmitter = new Emitter<readonly FileChange[]>();
+    readonly onDidChangeFile = this.onDidChangeFileEmitter.event;
+    onFileWatchError: Event<void> = Event.None;
+
+    @inject(OPFSInitialization)
+    protected readonly initialization: OPFSInitialization;
+
+    private directoryHandle: FileSystemDirectoryHandle;
+    private initialized: Promise<true>;
+
+    @postConstruct()
+    protected init(): void {
+        const setup = async (): Promise<true> => {
+            this.directoryHandle = await this.initialization.getRootDirectory();
+            await this.initialization.initializeFS(new Proxy(this, {
+                get(target, prop, receiver): unknown {
+                    if (prop === 'initialized') {
+                        return Promise.resolve(true);
+                    }
+                    return Reflect.get(target, prop, receiver);
+                }
+            }));
+            return true;
+        };
+        this.initialized = setup();
+    }
+
+    watch(_resource: URI, _opts: WatchOptions): Disposable {
+        return Disposable.NULL;
+    }
+
+    async exists(resource: URI): Promise<boolean> {
+        try {
+            await this.initialized;
+            await this.toFileSystemHandle(resource);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async stat(resource: URI): Promise<Stat> {
+        try {
+            await this.initialized;
+
+            const handle = await this.toFileSystemHandle(resource);
+
+            if (handle.kind === 'file') {
+                const fileHandle = handle as FileSystemFileHandle;
+                const file = await fileHandle.getFile();
+                return {
+                    type: FileType.File,
+                    ctime: file.lastModified,
+                    mtime: file.lastModified,
+                    size: file.size
+                };
+            } else if (handle.kind === 'directory') {
+                return {
+                    type: FileType.Directory,
+                    ctime: 0,
+                    mtime: 0,
+                    size: 0
+                };
+            }
+
+            throw createFileSystemProviderError('Unknown file handle error', FileSystemProviderErrorCode.Unknown);
+        } catch (error) {
+            throw toFileSystemProviderError(error);
+        }
+    }
+
+    async mkdir(resource: URI): Promise<void> {
+        await this.initialized;
+        try {
+            await this.toFileSystemHandle(resource, { create: true, isDirectory: true });
+            this.onDidChangeFileEmitter.fire([{ resource, type: FileChangeType.ADDED }]);
+        } catch (error) {
+            throw toFileSystemProviderError(error, true);
+        }
+    }
+
+    async readdir(resource: URI): Promise<[string, FileType][]> {
+        await this.initialized;
+
+        try {
+            // Get the directory handle from the directoryHandle
+            const directoryHandle = await this.toFileSystemHandle(resource, { create: false, isDirectory: true }) as FileSystemDirectoryHandle;
+
+            const result: [string, FileType][] = [];
+
+            // Iterate through the entries in the directory (files and subdirectories)
+            for await (const [name, handle] of directoryHandle.entries()) {
+                // Determine the type of the entry (file or directory)
+                if (handle.kind === 'file') {
+                    result.push([name, FileType.File]);
+                } else if (handle.kind === 'directory') {
+                    result.push([name, FileType.Directory]);
+                }
+            }
+
+            return result;
+        } catch (error) {
+            throw toFileSystemProviderError(error, true);
+        }
+    }
+
+    async delete(resource: URI, _opts: FileDeleteOptions): Promise<void> {
+        await this.initialized;
+        try {
+            const parentURI = resource.parent;
+            const parentHandle = await this.toFileSystemHandle(parentURI, { create: false, isDirectory: true });
+            if (parentHandle.kind !== 'directory') {
+                throw createFileSystemProviderError(new Error('Parent is not a directory'), FileSystemProviderErrorCode.FileNotADirectory);
+            }
+            const name = resource.path.base;
+            return (parentHandle as FileSystemDirectoryHandle).removeEntry(name, { recursive: _opts.recursive });
+        } catch (error) {
+            throw toFileSystemProviderError(error);
+        } finally {
+            this.onDidChangeFileEmitter.fire([{ resource, type: FileChangeType.DELETED }]);
+        }
+    }
+
+    async rename(from: URI, to: URI, opts: FileOverwriteOptions): Promise<void> {
+        await this.initialized;
+
+        try {
+            const fromHandle = await this.toFileSystemHandle(from);
+            // Check whether the source is a file or directory
+            if (fromHandle.kind === 'directory') {
+                // Create the new directory and get the handle
+                await this.mkdir(to);
+                const toHandle = await this.toFileSystemHandle(to) as FileSystemDirectoryHandle;
+                await copyDirectoryContents(fromHandle as FileSystemDirectoryHandle, toHandle);
+
+                // Delete the old directory
+                await this.delete(from, { recursive: true, useTrash: false });
+            } else {
+                const content = await this.readFile(from);
+                await this.writeFile(to, content, { create: true, overwrite: opts.overwrite });
+                await this.delete(from, { recursive: true, useTrash: false });
+            }
+
+            this.onDidChangeFileEmitter.fire([{ resource: to, type: FileChangeType.ADDED }]);
+        } catch (error) {
+            throw toFileSystemProviderError(error);
+        }
+    }
+
+    async readFile(resource: URI): Promise<Uint8Array> {
+        await this.initialized;
+
+        try {
+            // Get the file handle from the directoryHandle
+            const fileHandle = await this.toFileSystemHandle(resource, { create: false, isDirectory: false }) as FileSystemFileHandle;
+
+            // Get the file itself (which includes the content)
+            const file = await fileHandle.getFile();
+
+            // Read the file as an ArrayBuffer and convert it to Uint8Array
+            const arrayBuffer = await file.arrayBuffer();
+            return new Uint8Array(arrayBuffer);
+        } catch (error) {
+            throw toFileSystemProviderError(error, false);
+        }
+    }
+
+    async writeFile(resource: URI, content: Uint8Array, opts: FileWriteOptions): Promise<void> {
+        await this.initialized;
+        let writeableHandle: FileSystemWritableFileStream | undefined = undefined;
+        try {
+            // Validate target unless { create: true, overwrite: true }
+            if (!opts.create || !opts.overwrite) {
+                const fileExists = await this.stat(resource).then(() => true, () => false);
+                if (fileExists) {
+                    if (!opts.overwrite) {
+                        throw createFileSystemProviderError('File already exists', FileSystemProviderErrorCode.FileExists);
+                    }
+                } else {
+                    if (!opts.create) {
+                        throw createFileSystemProviderError('File does not exist', FileSystemProviderErrorCode.FileNotFound);
+                    }
+                }
+            }
+
+            const handle = await this.toFileSystemHandle(resource, { create: true, isDirectory: false }) as FileSystemFileHandle;
+
+            // Open
+            writeableHandle = await handle?.createWritable();
+
+            // Write content at once
+            await writeableHandle?.write(content);
+
+            this.onDidChangeFileEmitter.fire([{ resource: resource, type: FileChangeType.UPDATED }]);
+        } catch (error) {
+            throw toFileSystemProviderError(error, false);
+        } finally {
+            if (typeof writeableHandle !== 'undefined') {
+                await writeableHandle.close();
+            }
+        }
+    }
+
+    /**
+     * Returns the FileSystemHandle for the given resource given by a URI.
+     * @param resource URI/path of the resource
+     * @param options Options for the creation of the handle while traversing the path
+     * @returns FileSystemHandle for the given resource
+     */
+    private async toFileSystemHandle(resource: URI, options?: CreateFileSystemHandleOptions): Promise<FileSystemHandle> {
+        const pathParts = resource.path.toString().split(Path.separator).filter(Boolean);
+
+        return recursiveFileSystemHandle(this.directoryHandle, pathParts, options);
+    }
+}
+
+// #region Helper functions
+async function recursiveFileSystemHandle(handle: FileSystemHandle, pathParts: string[], options?: CreateFileSystemHandleOptions): Promise<FileSystemHandle> {
+    // We reached the end of the path, this happens only when not creating
+    if (pathParts.length === 0) {
+        return handle;
+    }
+    // If there are parts left, the handle must be a directory
+    if (handle.kind !== 'directory') {
+        throw createFileSystemProviderError('Not a directory', FileSystemProviderErrorCode.FileNotADirectory);
+    }
+    const dirHandle = handle as FileSystemDirectoryHandle;
+    // We need to create it and thus we need to stop early to create the file or directory
+    if (pathParts.length === 1 && options?.create) {
+        if (options?.isDirectory) {
+            return dirHandle.getDirectoryHandle(pathParts[0], { create: options.create });
+        } else {
+            return dirHandle.getFileHandle(pathParts[0], { create: options.create });
+        }
+    }
+
+    // Continue to resolve the path
+    const part = pathParts.shift()!;
+    for await (const entry of dirHandle.entries()) {
+        // Check the entry name in the current directory
+        if (entry[0] === part) {
+            return recursiveFileSystemHandle(entry[1], pathParts, options);
+        }
+    }
+
+    // If we haven't found the part, we need to create it along the way
+    if (options?.create) {
+        const newHandle = await dirHandle.getDirectoryHandle(part, { create: true });
+        return recursiveFileSystemHandle(newHandle, pathParts, options);
+    }
+
+    throw createFileSystemProviderError('File not found', FileSystemProviderErrorCode.FileNotFound);
+}
+
+// Function to copy directory contents recursively
+async function copyDirectoryContents(sourceHandle: FileSystemDirectoryHandle, destinationHandle: FileSystemDirectoryHandle): Promise<void> {
+    for await (const [name, handle] of sourceHandle.entries()) {
+        if (handle.kind === 'file') {
+            const file = await (handle as FileSystemFileHandle).getFile();
+            const newFileHandle = await destinationHandle.getFileHandle(name, { create: true });
+            const writable = await newFileHandle.createWritable();
+            try {
+                await writable.write(await file.arrayBuffer());
+            } finally {
+                await writable.close();
+            }
+        } else if (handle.kind === 'directory') {
+            const newSubDirHandle = await destinationHandle.getDirectoryHandle(name, { create: true });
+            await copyDirectoryContents(handle as FileSystemDirectoryHandle, newSubDirHandle);
+        }
+    }
+}
+
+function toFileSystemProviderError(error: DOMException, is_dir?: boolean): FileSystemProviderError {
+    if (error instanceof FileSystemProviderError) {
+        return error; // avoid double conversion
+    }
+
+    let code: FileSystemProviderErrorCode;
+    switch (error.name) {
+        case 'NotFoundError':
+            code = FileSystemProviderErrorCode.FileNotFound;
+            break;
+        case 'InvalidModificationError':
+            code = FileSystemProviderErrorCode.FileExists;
+            break;
+        case 'NotAllowedError':
+            code = FileSystemProviderErrorCode.NoPermissions;
+            break;
+        case 'TypeMismatchError':
+            if (!is_dir) {
+                code = FileSystemProviderErrorCode.FileIsADirectory;
+            } else {
+                code = FileSystemProviderErrorCode.FileNotADirectory;
+            }
+
+            break;
+        case 'QuotaExceededError':
+            code = FileSystemProviderErrorCode.FileTooLarge;
+            break;
+        default:
+            code = FileSystemProviderErrorCode.Unknown;
+    }
+
+    return createFileSystemProviderError(error, code);
+}
+// #endregion

package/src/common/download/README.md

@@ -3,6 +3,7 @@
 Provides the file download contribution to the `Files` navigator.
 
 Supports single and multi file downloads.
+
  1. A single file will be downloaded as is.
  2. Folders will be downloaded az tar archives.
  3. When downloading multiple files, the name of the closest common parent directory will be used for the archive.
@@ -10,10 +11,11 @@ Supports single and multi file downloads.
 
 ### REST API
 
- - To download a single file or folder use the following endpoint: `GET /files/?uri=/encoded/file/uri/to/the/resource`.
-   - Example: `curl -X GET http://localhost:3000/files/?uri=file:///Users/akos.kitta/git/theia/package.json`.
+- To download a single file or folder use the following endpoint: `GET /files/?uri=/encoded/file/uri/to/the/resource`.
+  - Example: `curl -X GET http://localhost:3000/files/?uri=file:///Users/akos.kitta/git/theia/package.json`.
+
+- To download multiple files (from the same folder) use the `PUT /files/` endpoint with the `application/json` content type header and the following body format:
 
- - To download multiple files (from the same folder) use the `PUT /files/` endpoint with the `application/json` content type header and the following body format:
     ```json
     {
         "uri": [
@@ -22,10 +24,12 @@ Supports single and multi file downloads.
         ]
     }
     ```
+
    ```
    curl -X PUT -H "Content-Type: application/json" -d '{ "uris": ["file:///Users/akos.kitta/git/theia/package.json", "file:///Users/akos.kitta/git/theia/README.md"] }' http://localhost:3000/files/
    ```
 
 ## License
+
 - [Eclipse Public License 2.0](http://www.eclipse.org/legal/epl-2.0/)
-- [一 (Secondary) GNU General Public License, version 2 with the GNU Classpath Exception](https://projects.eclipse.org/license/secondary-gpl-2.0-cp)
+- [一 (Secondary) GNU General Public License, version 2 with the GNU Classpath Exception](https://projects.eclipse.org/license/secondary-gpl-2.0-cp)