@codingame/monaco-vscode-api 1.78.5 → 1.78.6-next.0

package/dist/vscode/vs/workbench/contrib/files/browser/fileImportExport.js

@@ -0,0 +1,708 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { IDialogService, IFileDialogService, getFileNamesMessage } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { ByteSize, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { IExplorerService } from './files.js';
+import { VIEW_ID } from '../common/files.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { Promises, RunOnceWorker, Limiter } from 'monaco-editor/esm/vs/base/common/async.js';
+import { newWriteableBufferStream, VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { joinPath, dirname, basename } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ResourceFileEdit } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { ExplorerItem } from '../common/explorerModel.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IHostService } from '../../../services/host/browser/host.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { extractEditorsAndFilesDropData } from 'monaco-editor/esm/vs/platform/dnd/browser/dnd.js';
+import { IWorkspaceEditingService } from '../../../services/workspaces/common/workspaceEditing.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { triggerDownload } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { FileAccess, Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { mnemonicButtonLabel } from 'monaco-editor/esm/vs/base/common/labels.js';
+import { listenStream } from 'monaco-editor/esm/vs/base/common/stream.js';
+import { toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { canceled } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { WebFileSystemAccess } from 'monaco-editor/esm/vs/platform/files/browser/webFileSystemAccess.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+let BrowserFileUpload = class BrowserFileUpload {
+    constructor(progressService, dialogService, explorerService, editorService, fileService) {
+        this.progressService = progressService;
+        this.dialogService = dialogService;
+        this.explorerService = explorerService;
+        this.editorService = editorService;
+        this.fileService = fileService;
+    }
+    upload(target, source) {
+        const cts = ( new CancellationTokenSource());
+        const uploadPromise = this.progressService.withProgress({
+            location: 10 ,
+            delay: 800,
+            cancellable: true,
+            title: ( localize('uploadingFiles', "Uploading"))
+        }, async (progress) => this.doUpload(target, this.toTransfer(source), progress, cts.token), () => cts.dispose(true));
+        this.progressService.withProgress({ location: VIEW_ID, delay: 500 }, () => uploadPromise);
+        return uploadPromise;
+    }
+    toTransfer(source) {
+        if (source instanceof DragEvent) {
+            return source.dataTransfer;
+        }
+        const transfer = { items: [] };
+        for (const file of source) {
+            transfer.items.push({
+                webkitGetAsEntry: () => {
+                    return {
+                        name: file.name,
+                        isDirectory: false,
+                        isFile: true,
+                        createReader: () => { throw new Error('Unsupported for files'); },
+                        file: resolve => resolve(file)
+                    };
+                }
+            });
+        }
+        return transfer;
+    }
+    async doUpload(target, source, progress, token) {
+        const items = source.items;
+        const entries = [];
+        for (const item of items) {
+            entries.push(item.webkitGetAsEntry());
+        }
+        const results = [];
+        const operation = {
+            startTime: Date.now(),
+            progressScheduler: ( new RunOnceWorker(steps => { progress.report(steps[steps.length - 1]); }, 1000)),
+            filesTotal: entries.length,
+            filesUploaded: 0,
+            totalBytesUploaded: 0
+        };
+        const uploadLimiter = ( new Limiter(BrowserFileUpload.MAX_PARALLEL_UPLOADS));
+        await Promises.settled(( entries.map(entry => {
+            return uploadLimiter.queue(async () => {
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                if (target && entry.name && target.getChild(entry.name)) {
+                    const { confirmed } = await this.dialogService.confirm(getFileOverwriteConfirm(entry.name));
+                    if (!confirmed) {
+                        return;
+                    }
+                    await this.explorerService.applyBulkEdit([( new ResourceFileEdit(
+                        joinPath(target.resource, entry.name),
+                        undefined,
+                        { recursive: true, folder: target.getChild(entry.name)?.isDirectory }
+                    ))], {
+                        undoLabel: ( localize('overwrite', "Overwrite {0}", entry.name)),
+                        progressLabel: ( localize('overwriting', "Overwriting {0}", entry.name)),
+                    });
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
+                }
+                const result = await this.doUploadEntry(entry, target.resource, target, progress, operation, token);
+                if (result) {
+                    results.push(result);
+                }
+            });
+        })));
+        operation.progressScheduler.dispose();
+        const firstUploadedFile = results[0];
+        if (!token.isCancellationRequested && firstUploadedFile?.isFile) {
+            await this.editorService.openEditor({ resource: firstUploadedFile.resource, options: { pinned: true } });
+        }
+    }
+    async doUploadEntry(entry, parentResource, target, progress, operation, token) {
+        if (token.isCancellationRequested || !entry.name || (!entry.isFile && !entry.isDirectory)) {
+            return undefined;
+        }
+        let fileBytesUploaded = 0;
+        const reportProgress = (fileSize, bytesUploaded) => {
+            fileBytesUploaded += bytesUploaded;
+            operation.totalBytesUploaded += bytesUploaded;
+            const bytesUploadedPerSecond = operation.totalBytesUploaded / ((Date.now() - operation.startTime) / 1000);
+            let message;
+            if (fileSize < ByteSize.MB) {
+                if (operation.filesTotal === 1) {
+                    message = `${entry.name}`;
+                }
+                else {
+                    message = ( localize(
+                        'uploadProgressSmallMany',
+                        "{0} of {1} files ({2}/s)",
+                        operation.filesUploaded,
+                        operation.filesTotal,
+                        ByteSize.formatSize(bytesUploadedPerSecond)
+                    ));
+                }
+            }
+            else {
+                message = ( localize(
+                    'uploadProgressLarge',
+                    "{0} ({1} of {2}, {3}/s)",
+                    entry.name,
+                    ByteSize.formatSize(fileBytesUploaded),
+                    ByteSize.formatSize(fileSize),
+                    ByteSize.formatSize(bytesUploadedPerSecond)
+                ));
+            }
+            operation.progressScheduler.work({ message });
+        };
+        operation.filesUploaded++;
+        reportProgress(0, 0);
+        const resource = joinPath(parentResource, entry.name);
+        if (entry.isFile) {
+            const file = await ( new Promise((resolve, reject) => entry.file(resolve, reject)));
+            if (token.isCancellationRequested) {
+                return undefined;
+            }
+            if (typeof file.stream === 'function' && file.size > ByteSize.MB) {
+                await this.doUploadFileBuffered(resource, file, reportProgress, token);
+            }
+            else {
+                await this.doUploadFileUnbuffered(resource, file, reportProgress);
+            }
+            return { isFile: true, resource };
+        }
+        else {
+            await this.fileService.createFolder(resource);
+            if (token.isCancellationRequested) {
+                return undefined;
+            }
+            const dirReader = entry.createReader();
+            const childEntries = [];
+            let done = false;
+            do {
+                const childEntriesChunk = await ( new Promise((resolve, reject) => dirReader.readEntries(resolve, reject)));
+                if (childEntriesChunk.length > 0) {
+                    childEntries.push(...childEntriesChunk);
+                }
+                else {
+                    done = true;
+                }
+            } while (!done && !token.isCancellationRequested);
+            operation.filesTotal += childEntries.length;
+            const folderTarget = target && target.getChild(entry.name) || undefined;
+            const fileChildEntries = [];
+            const folderChildEntries = [];
+            for (const childEntry of childEntries) {
+                if (childEntry.isFile) {
+                    fileChildEntries.push(childEntry);
+                }
+                else if (childEntry.isDirectory) {
+                    folderChildEntries.push(childEntry);
+                }
+            }
+            const fileUploadQueue = ( new Limiter(BrowserFileUpload.MAX_PARALLEL_UPLOADS));
+            await Promises.settled(( fileChildEntries.map(fileChildEntry => {
+                return fileUploadQueue.queue(() => this.doUploadEntry(fileChildEntry, resource, folderTarget, progress, operation, token));
+            })));
+            for (const folderChildEntry of folderChildEntries) {
+                await this.doUploadEntry(folderChildEntry, resource, folderTarget, progress, operation, token);
+            }
+            return { isFile: false, resource };
+        }
+    }
+    async doUploadFileBuffered(resource, file, progressReporter, token) {
+        const writeableStream = newWriteableBufferStream({
+            highWaterMark: 10
+        });
+        const writeFilePromise = this.fileService.writeFile(resource, writeableStream);
+        try {
+            const reader = file.stream().getReader();
+            let res = await reader.read();
+            while (!res.done) {
+                if (token.isCancellationRequested) {
+                    break;
+                }
+                const buffer = VSBuffer.wrap(res.value);
+                await writeableStream.write(buffer);
+                if (token.isCancellationRequested) {
+                    break;
+                }
+                progressReporter(file.size, buffer.byteLength);
+                res = await reader.read();
+            }
+            writeableStream.end(undefined);
+        }
+        catch (error) {
+            writeableStream.error(error);
+            writeableStream.end();
+        }
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        await writeFilePromise;
+    }
+    doUploadFileUnbuffered(resource, file, progressReporter) {
+        return ( new Promise((resolve, reject) => {
+            const reader = ( new FileReader());
+            reader.onload = async (event) => {
+                try {
+                    if (event.target?.result instanceof ArrayBuffer) {
+                        const buffer = VSBuffer.wrap(( new Uint8Array(event.target.result)));
+                        await this.fileService.writeFile(resource, buffer);
+                        progressReporter(file.size, buffer.byteLength);
+                    }
+                    else {
+                        throw new Error('Could not read from dropped file.');
+                    }
+                    resolve();
+                }
+                catch (error) {
+                    reject(error);
+                }
+            };
+            reader.readAsArrayBuffer(file);
+        }));
+    }
+};
+BrowserFileUpload.MAX_PARALLEL_UPLOADS = 20;
+BrowserFileUpload = ( __decorate([
+    ( __param(0, IProgressService)),
+    ( __param(1, IDialogService)),
+    ( __param(2, IExplorerService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, IFileService))
+], BrowserFileUpload));
+let ExternalFileImport = class ExternalFileImport {
+    constructor(fileService, hostService, contextService, configurationService, dialogService, workspaceEditingService, explorerService, editorService, progressService, notificationService, instantiationService) {
+        this.fileService = fileService;
+        this.hostService = hostService;
+        this.contextService = contextService;
+        this.configurationService = configurationService;
+        this.dialogService = dialogService;
+        this.workspaceEditingService = workspaceEditingService;
+        this.explorerService = explorerService;
+        this.editorService = editorService;
+        this.progressService = progressService;
+        this.notificationService = notificationService;
+        this.instantiationService = instantiationService;
+    }
+    async import(target, source) {
+        const cts = ( new CancellationTokenSource());
+        const importPromise = this.progressService.withProgress({
+            location: 10 ,
+            delay: 800,
+            cancellable: true,
+            title: ( localize('copyingFiles', "Copying..."))
+        }, async () => await this.doImport(target, source, cts.token), () => cts.dispose(true));
+        this.progressService.withProgress({ location: VIEW_ID, delay: 500 }, () => importPromise);
+        return importPromise;
+    }
+    async doImport(target, source, token) {
+        const candidateFiles = coalesce(( (await this.instantiationService.invokeFunction(accessor => extractEditorsAndFilesDropData(accessor, source))).map(editor => editor.resource)));
+        await Promise.all(( candidateFiles.map(resource => this.fileService.activateProvider(resource.scheme))));
+        const files = coalesce(candidateFiles.filter(resource => this.fileService.hasProvider(resource)));
+        const resolvedFiles = await this.fileService.resolveAll(( files.map(file => ({ resource: file }))));
+        if (token.isCancellationRequested) {
+            return;
+        }
+        this.hostService.focus();
+        const folders = ( resolvedFiles.filter(resolvedFile => resolvedFile.success && resolvedFile.stat?.isDirectory).map(resolvedFile => ({ uri: resolvedFile.stat.resource })));
+        if (folders.length > 0 && target.isRoot) {
+            let ImportChoice;
+            ( (function(ImportChoice) {
+                ImportChoice[ImportChoice["Copy"] = 1] = "Copy";
+                ImportChoice[ImportChoice["Add"] = 2] = "Add";
+            })(ImportChoice || (ImportChoice = {})));
+            const buttons = [
+                {
+                    label: folders.length > 1 ?
+                        ( localize('copyFolders', "&&Copy Folders")) :
+                        ( localize('copyFolder', "&&Copy Folder")),
+                    run: () => ImportChoice.Copy
+                }
+            ];
+            let message;
+            const workspaceFolderSchemas = ( this.contextService.getWorkspace().folders.map(folder => folder.uri.scheme));
+            if (( folders.some(folder => workspaceFolderSchemas.indexOf(folder.uri.scheme) >= 0))) {
+                buttons.unshift({
+                    label: folders.length > 1 ?
+                        ( localize('addFolders', "&&Add Folders to Workspace")) :
+                        ( localize('addFolder', "&&Add Folder to Workspace")),
+                    run: () => ImportChoice.Add
+                });
+                message = folders.length > 1 ?
+                    ( localize(
+                        'dropFolders',
+                        "Do you want to copy the folders or add the folders to the workspace?"
+                    )) :
+                    ( localize(
+                        'dropFolder',
+                        "Do you want to copy '{0}' or add '{0}' as a folder to the workspace?",
+                        basename(folders[0].uri)
+                    ));
+            }
+            else {
+                message = folders.length > 1 ?
+                    ( localize('copyfolders', "Are you sure to want to copy folders?")) :
+                    ( localize(
+                        'copyfolder',
+                        "Are you sure to want to copy '{0}'?",
+                        basename(folders[0].uri)
+                    ));
+            }
+            const { result } = await this.dialogService.prompt({
+                type: Severity.Info,
+                message,
+                buttons,
+                cancelButton: true
+            });
+            if (result === ImportChoice.Add) {
+                return this.workspaceEditingService.addFolders(folders);
+            }
+            if (result === ImportChoice.Copy) {
+                return this.importResources(target, files, token);
+            }
+        }
+        else if (target instanceof ExplorerItem) {
+            return this.importResources(target, files, token);
+        }
+    }
+    async importResources(target, resources, token) {
+        if (resources && resources.length > 0) {
+            const targetStat = await this.fileService.resolve(target.resource);
+            if (token.isCancellationRequested) {
+                return;
+            }
+            const targetNames = ( new Set());
+            const caseSensitive = this.fileService.hasCapability(target.resource, 1024 );
+            if (targetStat.children) {
+                targetStat.children.forEach(child => {
+                    targetNames.add(caseSensitive ? child.name : child.name.toLowerCase());
+                });
+            }
+            let inaccessibleFileCount = 0;
+            const resourcesFiltered = coalesce((await Promises.settled(( resources.map(async (resource) => {
+                const fileDoesNotExist = !(await this.fileService.exists(resource));
+                if (fileDoesNotExist) {
+                    inaccessibleFileCount++;
+                    return undefined;
+                }
+                if (( targetNames.has(caseSensitive ? basename(resource) : basename(resource).toLowerCase()))) {
+                    const confirmationResult = await this.dialogService.confirm(getFileOverwriteConfirm(basename(resource)));
+                    if (!confirmationResult.confirmed) {
+                        return undefined;
+                    }
+                }
+                return resource;
+            })))));
+            if (inaccessibleFileCount > 0) {
+                this.notificationService.error(inaccessibleFileCount > 1 ? ( localize(
+                    'filesInaccessible',
+                    "Some or all of the dropped files could not be accessed for import."
+                )) : ( localize('fileInaccessible', "The dropped file could not be accessed for import.")));
+            }
+            const resourceFileEdits = ( resourcesFiltered.map(resource => {
+                const sourceFileName = basename(resource);
+                const targetFile = joinPath(target.resource, sourceFileName);
+                return ( new ResourceFileEdit(resource, targetFile, { overwrite: true, copy: true }));
+            }));
+            const undoLevel = this.configurationService.getValue().explorer.confirmUndo;
+            await this.explorerService.applyBulkEdit(resourceFileEdits, {
+                undoLabel: resourcesFiltered.length === 1 ?
+                    ( localize(
+                        { comment: ['substitution will be the name of the file that was imported'], key: 'importFile' },
+                        "Import {0}",
+                        basename(resourcesFiltered[0])
+                    )) :
+                    ( localize(
+                        { comment: ['substitution will be the number of files that were imported'], key: 'importnFile' },
+                        "Import {0} resources",
+                        resourcesFiltered.length
+                    )),
+                progressLabel: resourcesFiltered.length === 1 ?
+                    ( localize(
+                        { comment: ['substitution will be the name of the file that was copied'], key: 'copyingFile' },
+                        "Copying {0}",
+                        basename(resourcesFiltered[0])
+                    )) :
+                    ( localize(
+                        { comment: ['substitution will be the number of files that were copied'], key: 'copyingnFile' },
+                        "Copying {0} resources",
+                        resourcesFiltered.length
+                    )),
+                progressLocation: 10 ,
+                confirmBeforeUndo: undoLevel === "verbose"  || undoLevel === "default" ,
+            });
+            if (resourceFileEdits.length === 1) {
+                const item = this.explorerService.findClosest(resourceFileEdits[0].newResource);
+                if (item && !item.isDirectory) {
+                    this.editorService.openEditor({ resource: item.resource, options: { pinned: true } });
+                }
+            }
+        }
+    }
+};
+ExternalFileImport = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IHostService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IDialogService)),
+    ( __param(5, IWorkspaceEditingService)),
+    ( __param(6, IExplorerService)),
+    ( __param(7, IEditorService)),
+    ( __param(8, IProgressService)),
+    ( __param(9, INotificationService)),
+    ( __param(10, IInstantiationService))
+], ExternalFileImport));
+let FileDownload = class FileDownload {
+    constructor(fileService, explorerService, progressService, logService, fileDialogService, storageService) {
+        this.fileService = fileService;
+        this.explorerService = explorerService;
+        this.progressService = progressService;
+        this.logService = logService;
+        this.fileDialogService = fileDialogService;
+        this.storageService = storageService;
+    }
+    download(source) {
+        const cts = ( new CancellationTokenSource());
+        const downloadPromise = this.progressService.withProgress({
+            location: 10 ,
+            delay: 800,
+            cancellable: isWeb,
+            title: ( localize('downloadingFiles', "Downloading"))
+        }, async (progress) => this.doDownload(source, progress, cts), () => cts.dispose(true));
+        this.progressService.withProgress({ location: VIEW_ID, delay: 500 }, () => downloadPromise);
+        return downloadPromise;
+    }
+    async doDownload(sources, progress, cts) {
+        for (const source of sources) {
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            if (isWeb) {
+                await this.doDownloadBrowser(source.resource, progress, cts);
+            }
+            else {
+                await this.doDownloadNative(source, progress, cts);
+            }
+        }
+    }
+    async doDownloadBrowser(resource, progress, cts) {
+        const stat = await this.fileService.resolve(resource, { resolveMetadata: true });
+        if (cts.token.isCancellationRequested) {
+            return;
+        }
+        const maxBlobDownloadSize = 32 * ByteSize.MB;
+        const preferFileSystemAccessWebApis = stat.isDirectory || stat.size > maxBlobDownloadSize;
+        if (preferFileSystemAccessWebApis && WebFileSystemAccess.supported(window)) {
+            try {
+                const parentFolder = await window.showDirectoryPicker();
+                const operation = {
+                    startTime: Date.now(),
+                    progressScheduler: ( new RunOnceWorker(steps => { progress.report(steps[steps.length - 1]); }, 1000)),
+                    filesTotal: stat.isDirectory ? 0 : 1,
+                    filesDownloaded: 0,
+                    totalBytesDownloaded: 0,
+                    fileBytesDownloaded: 0
+                };
+                if (stat.isDirectory) {
+                    const targetFolder = await parentFolder.getDirectoryHandle(stat.name, { create: true });
+                    await this.downloadFolderBrowser(stat, targetFolder, operation, cts.token);
+                }
+                else {
+                    await this.downloadFileBrowser(parentFolder, stat, operation, cts.token);
+                }
+                operation.progressScheduler.dispose();
+            }
+            catch (error) {
+                this.logService.warn(error);
+                cts.cancel();
+            }
+        }
+        else if (stat.isFile) {
+            let bufferOrUri;
+            try {
+                bufferOrUri = (await this.fileService.readFile(stat.resource, { limits: { size: maxBlobDownloadSize } }, cts.token)).value.buffer;
+            }
+            catch (error) {
+                bufferOrUri = FileAccess.uriToBrowserUri(stat.resource);
+            }
+            if (!cts.token.isCancellationRequested) {
+                triggerDownload(bufferOrUri, stat.name);
+            }
+        }
+    }
+    async downloadFileBufferedBrowser(resource, target, operation, token) {
+        const contents = await this.fileService.readFileStream(resource, undefined, token);
+        if (token.isCancellationRequested) {
+            target.close();
+            return;
+        }
+        return ( new Promise((resolve, reject) => {
+            const sourceStream = contents.value;
+            const disposables = ( new DisposableStore());
+            disposables.add(toDisposable(() => target.close()));
+            disposables.add(once(token.onCancellationRequested)(() => {
+                disposables.dispose();
+                reject(canceled());
+            }));
+            disposables.add(listenStream(sourceStream, {
+                onData: data => {
+                    target.write(data.buffer);
+                    this.reportProgress(contents.name, contents.size, data.byteLength, operation);
+                },
+                onError: error => {
+                    disposables.dispose();
+                    reject(error);
+                },
+                onEnd: () => {
+                    disposables.dispose();
+                    resolve();
+                }
+            }));
+        }));
+    }
+    async downloadFileUnbufferedBrowser(resource, target, operation, token) {
+        const contents = await this.fileService.readFile(resource, undefined, token);
+        if (!token.isCancellationRequested) {
+            target.write(contents.value.buffer);
+            this.reportProgress(contents.name, contents.size, contents.value.byteLength, operation);
+        }
+        target.close();
+    }
+    async downloadFileBrowser(targetFolder, file, operation, token) {
+        operation.filesDownloaded++;
+        operation.fileBytesDownloaded = 0;
+        this.reportProgress(file.name, 0, 0, operation);
+        const targetFile = await targetFolder.getFileHandle(file.name, { create: true });
+        const targetFileWriter = await targetFile.createWritable();
+        if (file.size > ByteSize.MB) {
+            return this.downloadFileBufferedBrowser(file.resource, targetFileWriter, operation, token);
+        }
+        return this.downloadFileUnbufferedBrowser(file.resource, targetFileWriter, operation, token);
+    }
+    async downloadFolderBrowser(folder, targetFolder, operation, token) {
+        if (folder.children) {
+            operation.filesTotal += (( folder.children.map(child => child.isFile))).length;
+            for (const child of folder.children) {
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                if (child.isFile) {
+                    await this.downloadFileBrowser(targetFolder, child, operation, token);
+                }
+                else {
+                    const childFolder = await targetFolder.getDirectoryHandle(child.name, { create: true });
+                    const resolvedChildFolder = await this.fileService.resolve(child.resource, { resolveMetadata: true });
+                    await this.downloadFolderBrowser(resolvedChildFolder, childFolder, operation, token);
+                }
+            }
+        }
+    }
+    reportProgress(name, fileSize, bytesDownloaded, operation) {
+        operation.fileBytesDownloaded += bytesDownloaded;
+        operation.totalBytesDownloaded += bytesDownloaded;
+        const bytesDownloadedPerSecond = operation.totalBytesDownloaded / ((Date.now() - operation.startTime) / 1000);
+        let message;
+        if (fileSize < ByteSize.MB) {
+            if (operation.filesTotal === 1) {
+                message = name;
+            }
+            else {
+                message = ( localize(
+                    'downloadProgressSmallMany',
+                    "{0} of {1} files ({2}/s)",
+                    operation.filesDownloaded,
+                    operation.filesTotal,
+                    ByteSize.formatSize(bytesDownloadedPerSecond)
+                ));
+            }
+        }
+        else {
+            message = ( localize(
+                'downloadProgressLarge',
+                "{0} ({1} of {2}, {3}/s)",
+                name,
+                ByteSize.formatSize(operation.fileBytesDownloaded),
+                ByteSize.formatSize(fileSize),
+                ByteSize.formatSize(bytesDownloadedPerSecond)
+            ));
+        }
+        operation.progressScheduler.work({ message });
+    }
+    async doDownloadNative(explorerItem, progress, cts) {
+        progress.report({ message: explorerItem.name });
+        let defaultUri;
+        const lastUsedDownloadPath = this.storageService.get(FileDownload.LAST_USED_DOWNLOAD_PATH_STORAGE_KEY, -1 );
+        if (lastUsedDownloadPath) {
+            defaultUri = joinPath(URI.file(lastUsedDownloadPath), explorerItem.name);
+        }
+        else {
+            defaultUri = joinPath(explorerItem.isDirectory ?
+                await this.fileDialogService.defaultFolderPath(Schemas.file) :
+                await this.fileDialogService.defaultFilePath(Schemas.file), explorerItem.name);
+        }
+        const destination = await this.fileDialogService.showSaveDialog({
+            availableFileSystems: [Schemas.file],
+            saveLabel: mnemonicButtonLabel(( localize('downloadButton', "Download"))),
+            title: ( localize('chooseWhereToDownload', "Choose Where to Download")),
+            defaultUri
+        });
+        if (destination) {
+            this.storageService.store(FileDownload.LAST_USED_DOWNLOAD_PATH_STORAGE_KEY, dirname(destination).fsPath, -1 , 1 );
+            await this.explorerService.applyBulkEdit([( new ResourceFileEdit(explorerItem.resource, destination, { overwrite: true, copy: true }))], {
+                undoLabel: ( localize('downloadBulkEdit', "Download {0}", explorerItem.name)),
+                progressLabel: ( localize('downloadingBulkEdit', "Downloading {0}", explorerItem.name)),
+                progressLocation: 10
+            });
+        }
+        else {
+            cts.cancel();
+        }
+    }
+};
+FileDownload.LAST_USED_DOWNLOAD_PATH_STORAGE_KEY = 'workbench.explorer.downloadPath';
+FileDownload = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IExplorerService)),
+    ( __param(2, IProgressService)),
+    ( __param(3, ILogService)),
+    ( __param(4, IFileDialogService)),
+    ( __param(5, IStorageService))
+], FileDownload));
+function getFileOverwriteConfirm(name) {
+    return {
+        message: ( localize(
+            'confirmOverwrite',
+            "A file or folder with the name '{0}' already exists in the destination folder. Do you want to replace it?",
+            name
+        )),
+        detail: ( localize('irreversible', "This action is irreversible!")),
+        primaryButton: ( localize(
+            { key: 'replaceButtonLabel', comment: ['&& denotes a mnemonic'] },
+            "&&Replace"
+        )),
+        type: 'warning'
+    };
+}
+function getMultipleFilesOverwriteConfirm(files) {
+    if (files.length > 1) {
+        return {
+            message: ( localize(
+                'confirmManyOverwrites',
+                "The following {0} files and/or folders already exist in the destination folder. Do you want to replace them?",
+                files.length
+            )),
+            detail: getFileNamesMessage(files) + '\n' + ( localize('irreversible', "This action is irreversible!")),
+            primaryButton: ( localize(
+                { key: 'replaceButtonLabel', comment: ['&& denotes a mnemonic'] },
+                "&&Replace"
+            )),
+            type: 'warning'
+        };
+    }
+    return getFileOverwriteConfirm(basename(files[0]));
+}
+export { BrowserFileUpload, ExternalFileImport, FileDownload, getFileOverwriteConfirm, getMultipleFilesOverwriteConfirm };