@theia/filesystem 1.65.0-next.6 → 1.65.0

package/src/browser-only/upload/file-upload-service-impl.ts

@@ -0,0 +1,408 @@
+// *****************************************************************************
+// Copyright (C) 2025 Maksim Kachurin
+//
+// 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 { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
+import URI from '@theia/core/lib/common/uri';
+import { CancellationTokenSource, CancellationToken, checkCancelled, isCancelled } from '@theia/core/lib/common/cancellation';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import { MessageService } from '@theia/core/lib/common/message-service';
+import { Progress } from '@theia/core/lib/common/message-service-protocol';
+import throttle = require('@theia/core/shared/lodash.throttle');
+import { Semaphore } from 'async-mutex';
+import { FileService } from '../../browser/file-service';
+import { ConfirmDialog, Dialog } from '@theia/core/lib/browser';
+import { nls } from '@theia/core/lib/common/nls';
+import { Emitter, Event } from '@theia/core/lib/common/event';
+import { FileSystemPreferences } from '../../common/filesystem-preferences';
+import { fileToStream } from '@theia/core/lib/common/stream';
+import { minimatch } from 'minimatch';
+
+import type { FileUploadService } from '../../common/upload/file-upload';
+
+interface UploadState {
+    uploaded?: boolean;
+    failed?: boolean;
+}
+
+interface UploadFilesParams {
+    source: FileUploadService.Source,
+    progress: Progress,
+    token: CancellationToken,
+    onDidUpload?: (uri: string) => void,
+}
+
+@injectable()
+export class FileUploadServiceImpl implements FileUploadService {
+
+    static TARGET = 'target';
+    static UPLOAD = 'upload';
+
+    protected readonly onDidUploadEmitter = new Emitter<string[]>();
+    protected uploadForm: FileUploadService.Form;
+    protected deferredUpload?: Deferred<FileUploadService.UploadResult>;
+
+    @inject(FileSystemPreferences)
+    protected fileSystemPreferences: FileSystemPreferences;
+
+    @inject(FileService)
+    protected fileService: FileService;
+
+    @inject(MessageService)
+    protected readonly messageService: MessageService;
+
+    private readonly ignorePatterns: string[] = [];
+
+    get onDidUpload(): Event<string[]> {
+        return this.onDidUploadEmitter.event;
+    }
+
+    get maxConcurrentUploads(): number {
+        const maxConcurrentUploads = this.fileSystemPreferences['files.maxConcurrentUploads'];
+        return maxConcurrentUploads > 0 ? maxConcurrentUploads : Infinity;
+    }
+
+    @postConstruct()
+    protected init(): void {
+        this.uploadForm = this.createUploadForm();
+    }
+
+    protected createUploadForm(): FileUploadService.Form {
+        const targetInput = document.createElement('input');
+        targetInput.type = 'text';
+        targetInput.spellcheck = false;
+        targetInput.name = FileUploadServiceImpl.TARGET;
+        targetInput.classList.add('theia-input');
+
+        const fileInput = document.createElement('input');
+        fileInput.type = 'file';
+        fileInput.classList.add('theia-input');
+        fileInput.name = FileUploadServiceImpl.UPLOAD;
+        fileInput.multiple = true;
+
+        const form = document.createElement('form');
+        form.style.display = 'none';
+        form.enctype = 'multipart/form-data';
+        form.append(targetInput);
+        form.append(fileInput);
+
+        document.body.appendChild(form);
+
+        fileInput.addEventListener('change', () => {
+            if (this.deferredUpload && fileInput.value) {
+                const source: FileUploadService.Source = new FormData(form);
+                // clean up for reuse
+                fileInput.value = '';
+                const targetUri = new URI(<string>source.get(FileUploadServiceImpl.TARGET));
+                const { resolve, reject } = this.deferredUpload;
+                this.deferredUpload = undefined;
+                const { onDidUpload } = this.uploadForm;
+                this.withProgress(
+                    (progress, token) => this.uploadFiles(targetUri, { source, progress, token, onDidUpload })
+                ).then(resolve, reject);
+            }
+        });
+
+        return { targetInput, fileInput };
+    }
+
+    async upload(targetUri: string | URI, params: FileUploadService.UploadParams): Promise<FileUploadService.UploadResult> {
+        const { source, onDidUpload } = params || {};
+
+        if (source) {
+            return this.withProgress(
+                (progress, token) => this.uploadFiles(
+                    typeof targetUri === 'string' ? new URI(targetUri) : targetUri,
+                    { source, progress, token, onDidUpload }
+                )
+            );
+        }
+        this.deferredUpload = new Deferred<FileUploadService.UploadResult>();
+        this.uploadForm.targetInput.value = String(targetUri);
+        this.uploadForm.fileInput.click();
+        this.uploadForm.onDidUpload = onDidUpload;
+        return this.deferredUpload.promise;
+    }
+
+    protected async withProgress<T>(
+        cb: (progress: Progress, token: CancellationToken) => Promise<T>
+    ): Promise<T> {
+        const cancellationSource = new CancellationTokenSource();
+        const { token } = cancellationSource;
+        const text = nls.localize('theia/filesystem/uploadFiles', 'Saving Files');
+        const progress = await this.messageService.showProgress(
+            { text, options: { cancelable: true } },
+            () => cancellationSource.cancel()
+        );
+        try {
+            return await cb(progress, token);
+        } finally {
+            progress.cancel();
+        }
+    }
+
+    protected async confirmOverwrite(fileUri: URI): Promise<boolean> {
+        const dialog = new ConfirmDialog({
+            title: nls.localizeByDefault('Replace'),
+            msg: nls.localizeByDefault("A file or folder with the name '{0}' already exists in the destination folder. Do you want to replace it?", fileUri.path.base),
+            ok: nls.localizeByDefault('Replace'),
+            cancel: Dialog.CANCEL
+        });
+        return !!await dialog.open();
+    }
+
+    /**
+     * Upload all files to the filesystem
+     */
+    protected async uploadFiles(targetUri: URI, params: UploadFilesParams): Promise<FileUploadService.UploadResult> {
+        const status = new Map<URI, UploadState>();
+
+        const report = throttle(() => {
+            const list = Array.from(status.values());
+            const total = list.length;
+            const done = list.filter(item => item.uploaded).length;
+
+            params.progress.report({
+                message: nls.localize('theia/filesystem/processedOutOf', 'Processed {0} out of {1}', done, total),
+                work: { total, done }
+            });
+        }, 100);
+
+        const uploads: Promise<void>[] = [];
+        const uploadSemaphore = new Semaphore(this.maxConcurrentUploads);
+
+        try {
+            const files = await this.enumerateFiles(targetUri, params.source, params.token);
+
+            for (const { file, uri } of files) {
+                checkCancelled(params.token);
+
+                // Check exists and confirm overwrite before adding to queue
+                if (await this.fileService.exists(uri) && !await this.confirmOverwrite(uri)) {
+                    continue;
+                }
+
+                status.set(uri, {
+                    uploaded: false
+                });
+                report();
+
+                uploads.push(uploadSemaphore.runExclusive(async () => {
+                    const entry = status.get(uri);
+
+                    try {
+                        checkCancelled(params.token);
+
+                        await this.uploadFile(file, uri);
+
+                        if (entry) {
+                            entry.uploaded = true;
+                            report();
+                        }
+
+                        if (params.onDidUpload) {
+                            params.onDidUpload(uri.toString(true));
+                        }
+                    } catch (error) {
+                        if (entry) {
+                            entry.failed = true;
+                            report();
+                        }
+                        throw error;
+                    }
+                }));
+            }
+
+            checkCancelled(params.token);
+            await Promise.all(uploads);
+        } catch (error) {
+            uploadSemaphore.cancel();
+
+            if (!isCancelled(error)) {
+                this.messageService.error(nls.localize('theia/filesystem/uploadFailed', 'An error occurred while saving a file. {0}', error.message));
+                throw error;
+            }
+        }
+
+        const uploaded = Array.from(status.keys()).map(uri => uri.toString(true));
+
+        this.onDidUploadEmitter.fire(uploaded);
+
+        return { uploaded };
+    }
+
+    /**
+     * Upload (write) a file directly to the filesystem
+     */
+    protected async uploadFile(
+        file: File,
+        targetUri: URI
+    ): Promise<void> {
+        await this.fileService.writeFile(targetUri, fileToStream(file));
+    }
+
+    /**
+     * Normalize sources into an array of { file, uri } objects
+     */
+    protected async enumerateFiles(targetUri: URI, source: FileUploadService.Source, token: CancellationToken): Promise<{ file: File; uri: URI }[]> {
+        checkCancelled(token);
+
+        if (source instanceof FormData) {
+            // Handle FormData declaratively
+            const files = source.getAll(FileUploadServiceImpl.UPLOAD)
+                .filter((entry): entry is File => entry instanceof File)
+                .filter(entry => this.shouldIncludeFile(entry.name))
+                .map(entry => ({
+                    file: entry,
+                    uri: targetUri.resolve(entry.name)
+                }));
+
+            return files;
+        } else if (source instanceof DataTransfer) {
+            // Use WebKit Entries for folder traversal
+            if (source.items && this.supportsWebKitEntries()) {
+                // Collect all files first
+                const allFiles: { file: File; uri: URI }[] = [];
+                const items = Array.from(source.items);
+                const entries = items.map(item => item.webkitGetAsEntry()).filter((entry): entry is WebKitEntry => !!entry);
+
+                for (let i = 0; i < entries.length; i++) {
+                    const entry = entries[i];
+                    const filesFromEntry = await this.traverseEntry(targetUri, entry!, token);
+
+                    allFiles.push(...filesFromEntry);
+                }
+
+                return allFiles;
+            } else {
+                // Fall back to flat file list
+                return Array.from(source.files)
+                    .filter((file): file is File => !!file)
+                    .filter(file => this.shouldIncludeFile(file.name))
+                    .map(file => ({
+                        file,
+                        uri: targetUri.resolve(file.name)
+                    }));
+            }
+        } else {
+            // Handle CustomDataTransfer declaratively
+            const files = await Promise.all(
+                Array.from(source)
+                    .map(async ([, item]) => {
+                        const fileData = item.asFile();
+                        if (fileData && this.shouldIncludeFile(fileData.name)) {
+                            const data = await fileData.data();
+                            return {
+                                file: new File([data as BlobPart], fileData.name, { type: 'application/octet-stream' }),
+                                uri: targetUri.resolve(fileData.name)
+                            };
+                        }
+                        return undefined;
+                    })
+            );
+
+            return files.filter(Boolean) as { file: File; uri: URI }[];
+        }
+    }
+
+    /**
+     * Traverse WebKit Entries (files and folders)
+     */
+    protected async traverseEntry(
+        base: URI,
+        entry: WebKitEntry,
+        token: CancellationToken
+    ): Promise<{ file: File; uri: URI }[]> {
+        if (!entry) {
+            return [];
+        }
+
+        // Skip system entries
+        if (!this.shouldIncludeFile(entry.name)) {
+            return [];
+        }
+
+        // directory
+        if (entry.isDirectory) {
+            const dir = entry as WebKitDirectoryEntry;
+            const newBase = base.resolve(dir.name);
+
+            const entries = await this.readAllEntries(dir, token);
+            checkCancelled(token);
+
+            const chunks = await Promise.all(
+                entries.map(sub => this.traverseEntry(newBase, sub, token))
+            );
+
+            return chunks.flat();
+        }
+
+        // file
+        const fileEntry = entry as WebKitFileEntry;
+        const file = await this.readFileEntry(fileEntry, token);
+        checkCancelled(token);
+
+        return [{ file, uri: base.resolve(entry.name) }];
+    }
+
+    /**
+     * Read all entries from a WebKit directory entry
+     */
+    protected async readAllEntries(
+        dir: WebKitDirectoryEntry,
+        token: CancellationToken
+    ): Promise<WebKitEntry[]> {
+        const reader = dir.createReader();
+        const out: WebKitEntry[] = [];
+
+        while (true) {
+            checkCancelled(token);
+
+            const batch = await new Promise<WebKitEntry[]>((resolve, reject) =>
+                reader.readEntries(resolve, reject)
+            );
+
+            if (!batch.length) {break; }
+            out.push(...batch);
+
+            // yield to the event loop to keep UI responsive
+            await Promise.resolve();
+        }
+        return out;
+    }
+
+    /**
+     * Read a file from a WebKit file entry
+     */
+    protected async readFileEntry(
+        fileEntry: WebKitFileEntry,
+        token: CancellationToken
+    ): Promise<File> {
+        checkCancelled(token);
+        try {
+            return await new Promise<File>((resolve, reject) => fileEntry.file(resolve, reject));
+        } catch (err) {
+            throw err;
+        }
+    }
+
+    protected supportsWebKitEntries(): boolean {
+        return typeof DataTransferItem.prototype.webkitGetAsEntry === 'function';
+    }
+
+    protected shouldIncludeFile(path: string): boolean {
+        return !this.ignorePatterns.some((pattern: string) => minimatch(path, pattern));
+    }
+}

package/src/common/download/file-download.ts

@@ -0,0 +1,40 @@
+// *****************************************************************************
+// Copyright (C) 2018 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 { isObject, type URI } from '@theia/core/lib/common';
+
+export interface FileDownloadData {
+    readonly uris: string[];
+}
+
+export namespace FileDownloadData {
+    export function is(arg: unknown): arg is FileDownloadData {
+        return isObject(arg) && 'uris' in arg;
+    }
+}
+
+export namespace FileDownloadService {
+    export interface DownloadOptions {
+        // `true` if the download link has to be copied to the clipboard. This will not trigger the actual download. Defaults to `false`.
+        readonly copyLink?: boolean;
+    }
+}
+
+export const FileDownloadService = Symbol('FileDownloadService');
+
+export interface FileDownloadService {
+    download(uris: URI[], options?: FileDownloadService.DownloadOptions): Promise<void>;
+}

package/src/common/files.ts

@@ -970,8 +970,9 @@ export function etag(stat: { mtime: number | undefined, size: number | undefined
 
     return stat.mtime.toString(29) + stat.size.toString(31);
 }
+
 /**
- * Helper to format a raw byte size into a human readable label.
+ * Helper class for formatting and parsing byte sizes.
  */
 export class BinarySize {
     static readonly KB = 1024;
@@ -979,6 +980,9 @@ export class BinarySize {
     static readonly GB = BinarySize.MB * BinarySize.KB;
     static readonly TB = BinarySize.GB * BinarySize.KB;
 
+    /**
+     * Formats a byte size into a human readable string (e.g., "1.5MB", "2.3GB").
+     */
     static formatSize(size: number): string {
         if (size < BinarySize.KB) {
             return size + 'B';
@@ -994,4 +998,41 @@ export class BinarySize {
         }
         return (size / BinarySize.TB).toFixed(2) + 'TB';
     }
+
+    /**
+     * Parses a human readable string (e.g., "1.5MB", "2.3GB") and returns the size in bytes
+     */
+    static parseSize(sizeInput: string | number | undefined): number {
+        if (typeof sizeInput === 'number') {
+            return Math.round(sizeInput);
+        }
+
+        if (!sizeInput) {
+            return 0;
+        }
+
+        const trimmed = sizeInput.trim().toUpperCase();
+        const match = /^(\d+(?:\.\d+)?)([BKMG])?$/.exec(trimmed);
+
+        // If the format is invalid, return 0
+        if (!match) {
+            return 0;
+        }
+
+        const value = parseFloat(match[1]);
+        const unit = match[2];
+
+        switch (unit) {
+            case 'K':
+                return Math.round(value * BinarySize.KB);
+            case 'M':
+                return Math.round(value * BinarySize.MB);
+            case 'G':
+                return Math.round(value * BinarySize.GB);
+            case 'T':
+                return Math.round(value * BinarySize.TB);
+            default:
+                return Math.round(value);
+        }
+    }
 }

package/src/{browser → common}/filesystem-preferences.ts

@@ -15,15 +15,12 @@
 // *****************************************************************************
 
 import { interfaces } from '@theia/core/shared/inversify';
-import {
-    createPreferenceProxy,
-    PreferenceProxy,
-    PreferenceService,
-    PreferenceSchema,
-    PreferenceContribution
-} from '@theia/core/lib/browser/preferences';
-import { SUPPORTED_ENCODINGS } from '@theia/core/lib/browser/supported-encodings';
+import { createPreferenceProxy, PreferenceProxy } from '@theia/core/lib/common/preferences/preference-proxy';
+import { PreferenceScope } from '@theia/core/lib/common/preferences/preference-scope';
+import { PreferenceService } from '@theia/core/lib/common/preferences/preference-service';
+import { SUPPORTED_ENCODINGS } from '@theia/core/lib/common/supported-encodings';
 import { nls } from '@theia/core/lib/common/nls';
+import { PreferenceContribution, PreferenceSchema } from '@theia/core/lib/common/preferences/preference-schema';
 
 // See https://github.com/Microsoft/vscode/issues/30180
 export const WIN32_MAX_FILE_SIZE_MB = 300; // 300 MB
@@ -36,7 +33,6 @@ export const MAX_FILE_SIZE_MB = typeof process === 'object'
     : 32;
 
 export const filesystemPreferenceSchema: PreferenceSchema = {
-    type: 'object',
     properties: {
         'files.watcherExclude': {
             // eslint-disable-next-line max-len
@@ -48,14 +44,14 @@ export const filesystemPreferenceSchema: PreferenceSchema = {
                 '**/.git/objects/**': true,
                 '**/.git/subtree-cache/**': true
             },
-            scope: 'resource'
+            scope: PreferenceScope.Folder
         },
         'files.exclude': {
             type: 'object',
             default: { '**/.git': true, '**/.svn': true, '**/.hg': true, '**/CVS': true, '**/.DS_Store': true },
             // eslint-disable-next-line max-len
             markdownDescription: nls.localize('theia/filesystem/filesExclude', 'Configure glob patterns for excluding files and folders. For example, the file Explorer decides which files and folders to show or hide based on this setting.'),
-            scope: 'resource'
+            scope: PreferenceScope.Folder
         },
         'files.enableTrash': {
             type: 'boolean',
@@ -64,6 +60,7 @@ export const filesystemPreferenceSchema: PreferenceSchema = {
         },
         'files.associations': {
             type: 'object',
+            default: {},
             markdownDescription: nls.localizeByDefault(
                 // eslint-disable-next-line max-len
                 'Configure [glob patterns](https://aka.ms/vscode-glob-patterns) of file associations to languages (for example `\"*.extension\": \"html\"`). Patterns will match on the absolute path of a file if they contain a path separator and will match on the name of the file otherwise. These have precedence over the default associations of the languages installed.'
@@ -74,7 +71,8 @@ export const filesystemPreferenceSchema: PreferenceSchema = {
             default: false,
             // eslint-disable-next-line max-len
             description: nls.localizeByDefault('When enabled, the editor will attempt to guess the character set encoding when opening files. This setting can also be configured per language. Note, this setting is not respected by text search. Only {0} is respected.', '`#files.encoding#`'),
-            scope: 'language-overridable',
+            scope: PreferenceScope.Folder,
+            overridable: true,
             included: Object.keys(SUPPORTED_ENCODINGS).length > 1
         },
         'files.participants.timeout': {
@@ -93,13 +91,15 @@ export const filesystemPreferenceSchema: PreferenceSchema = {
             type: 'boolean',
             default: false,
             description: nls.localizeByDefault('When enabled, will trim trailing whitespace when saving a file.'),
-            scope: 'language-overridable'
+            scope: PreferenceScope.Folder,
+            overridable: true
         },
         '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'
+            scope: PreferenceScope.Folder,
+            overridable: true
         },
         'files.maxConcurrentUploads': {
             type: 'integer',

package/src/common/index.ts

@@ -16,3 +16,4 @@
 
 export * from './filesystem';
 export * from './filesystem-utils';
+export * from './filesystem-preferences';

package/src/common/io.ts

@@ -75,7 +75,12 @@ async function doReadFileIntoStream<T>(provider: FileSystemProviderWithOpenReadW
     const handle = await provider.open(resource, { create: false });
 
     // Check for cancellation
-    throwIfCancelled(token);
+    try {
+        throwIfCancelled(token);
+    } catch (error) {
+        await provider.close(handle);
+        throw error;
+    }
 
     try {
         let totalBytesRead = 0;

package/src/common/upload/file-upload.ts

@@ -0,0 +1,65 @@
+// *****************************************************************************
+// Copyright (C) 2019 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 URI from '@theia/core/lib/common/uri';
+import { CancellationToken } from '@theia/core/lib/common/cancellation';
+import { Progress } from '@theia/core/lib/common/message-service-protocol';
+import { Event } from '@theia/core/lib/common/event';
+
+export type CustomDataTransfer = Iterable<readonly [string, CustomDataTransferItem]>;
+
+export interface CustomDataTransferItem {
+    asFile(): {
+        readonly id: string;
+        readonly name: string;
+        data(): Promise<Uint8Array>;
+    } | undefined
+}
+
+export interface FileUploadService {
+    upload(targetUri: string | URI, params?: FileUploadService.UploadParams): Promise<FileUploadService.UploadResult>;
+    readonly onDidUpload: Event<string[]>;
+}
+
+export namespace FileUploadService {
+    export type Source = FormData | DataTransfer | CustomDataTransfer;
+    export interface UploadEntry {
+        file: File
+        uri: URI
+    }
+    export interface Context {
+        progress: Progress
+        token: CancellationToken
+        accept: (entry: UploadEntry) => Promise<void>
+    }
+    export interface Form {
+        targetInput: HTMLInputElement
+        fileInput: HTMLInputElement
+        onDidUpload?: (uri: string) => void
+    }
+    export interface UploadParams {
+        source?: FileUploadService.Source,
+        progress?: Progress,
+        token?: CancellationToken,
+        onDidUpload?: (uri: string) => void,
+        leaveInTemp?: boolean
+    }
+    export interface UploadResult {
+        uploaded: string[]
+    }
+}
+
+export const FileUploadService = Symbol('FileUploadService');