@theia/filesystem 1.45.1 → 1.46.0-next.137

package/src/browser/file-service.ts

@@ -51,7 +51,7 @@ import {
     toFileOperationResult, toFileSystemProviderErrorCode,
     ResolveFileResult, ResolveFileResultWithMetadata,
     MoveFileOptions, CopyFileOptions, BaseStatWithMetadata, FileDeleteOptions, FileOperationOptions, hasAccessCapability, hasUpdateCapability,
-    hasFileReadStreamCapability, FileSystemProviderWithFileReadStreamCapability
+    hasFileReadStreamCapability, FileSystemProviderWithFileReadStreamCapability, ReadOnlyMessageFileSystemProvider
 } from '../common/files';
 import { BinaryBuffer, BinaryBufferReadable, BinaryBufferReadableStream, BinaryBufferReadableBufferedStream, BinaryBufferWriteableStream } from '@theia/core/lib/common/buffer';
 import { ReadableStream, isReadableStream, isReadableBufferedStream, transform, consumeStream, peekStream, peekReadable, Readable } from '@theia/core/lib/common/stream';
@@ -68,6 +68,7 @@ import { readFileIntoStream } from '../common/io';
 import { FileSystemWatcherErrorHandler } from './filesystem-watcher-error-handler';
 import { FileSystemUtils } from '../common/filesystem-utils';
 import { nls } from '@theia/core';
+import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
 
 export interface FileOperationParticipant {
 
@@ -235,6 +236,15 @@ export interface FileSystemProviderCapabilitiesChangeEvent {
     scheme: string;
 }
 
+export interface FileSystemProviderReadOnlyMessageChangeEvent {
+    /** The affected file system provider for which this event was fired. */
+    provider: FileSystemProvider;
+    /** The uri for which the provider is registered */
+    scheme: string;
+    /** The new read only message */
+    message: MarkdownString | undefined;
+}
+
 /**
  * Represents the `FileSystemProviderActivation` event.
  * This event is fired by the {@link FileService} if it wants to activate the
@@ -342,6 +352,9 @@ export class FileService {
     private onDidChangeFileSystemProviderCapabilitiesEmitter = new Emitter<FileSystemProviderCapabilitiesChangeEvent>();
     readonly onDidChangeFileSystemProviderCapabilities = this.onDidChangeFileSystemProviderCapabilitiesEmitter.event;
 
+    private onDidChangeFileSystemProviderReadOnlyMessageEmitter = new Emitter<FileSystemProviderReadOnlyMessageChangeEvent>();
+    readonly onDidChangeFileSystemProviderReadOnlyMessage = this.onDidChangeFileSystemProviderReadOnlyMessageEmitter.event;
+
     private readonly providers = new Map<string, FileSystemProvider>();
     private readonly activations = new Map<string, Promise<FileSystemProvider>>();
 
@@ -364,6 +377,9 @@ export class FileService {
         providerDisposables.push(provider.onDidChangeFile(changes => this.onDidFilesChangeEmitter.fire(new FileChangesEvent(changes))));
         providerDisposables.push(provider.onFileWatchError(() => this.handleFileWatchError()));
         providerDisposables.push(provider.onDidChangeCapabilities(() => this.onDidChangeFileSystemProviderCapabilitiesEmitter.fire({ provider, scheme })));
+        if (ReadOnlyMessageFileSystemProvider.is(provider)) {
+            providerDisposables.push(provider.onDidChangeReadOnlyMessage(message => this.onDidChangeFileSystemProviderReadOnlyMessageEmitter.fire({ provider, scheme, message })));
+        }
 
         return Disposable.create(() => {
             this.onDidChangeFileSystemProviderRegistrationsEmitter.fire({ added: false, scheme, provider });
@@ -413,6 +429,14 @@ export class FileService {
         return this.providers.has(resource.scheme);
     }
 
+    getReadOnlyMessage(resource: URI): MarkdownString | undefined {
+        const provider = this.providers.get(resource.scheme);
+        if (ReadOnlyMessageFileSystemProvider.is(provider)) {
+            return provider.readOnlyMessage;
+        }
+        return undefined;
+    }
+
     /**
      * Tests if the service (i.e the {@link FileSystemProvider} registered for the given uri scheme) provides the given capability.
      * @param resource `URI` of the resource to test.
@@ -694,12 +718,7 @@ export class FileService {
     async read(resource: URI, options?: ReadTextFileOptions): Promise<TextFileContent> {
         const [bufferStream, decoder] = await this.doRead(resource, {
             ...options,
-            // optimization: since we know that the caller does not
-            // care about buffering, we indicate this to the reader.
-            // this reduces all the overhead the buffered reading
-            // has (open, read, close) if the provider supports
-            // unbuffered reading.
-            preferUnbuffered: true
+            preferUnbuffered: this.shouldReadUnbuffered(options)
         });
 
         return {
@@ -888,17 +907,25 @@ export class FileService {
             options.mtime < stat.mtime && options.etag !== etag({ mtime: options.mtime /* not using stat.mtime for a reason, see above */, size: stat.size });
     }
 
+    protected shouldReadUnbuffered(options?: ReadFileOptions): boolean {
+        // optimization: since we know that the caller does not
+        // care about buffering, we indicate this to the reader.
+        // this reduces all the overhead the buffered reading
+        // has (open, read, close) if the provider supports
+        // unbuffered reading.
+        //
+        // However, if we read only part of the file we still
+        // want buffered reading as otherwise we need to read
+        // the whole file and cut out the specified part later.
+        return options?.position === undefined && options?.length === undefined;
+    }
+
     async readFile(resource: URI, options?: ReadFileOptions): Promise<FileContent> {
         const provider = await this.withReadProvider(resource);
 
         const stream = await this.doReadAsFileStream(provider, resource, {
             ...options,
-            // optimization: since we know that the caller does not
-            // care about buffering, we indicate this to the reader.
-            // this reduces all the overhead the buffered reading
-            // has (open, read, close) if the provider supports
-            // unbuffered reading.
-            preferUnbuffered: true
+            preferUnbuffered: this.shouldReadUnbuffered(options)
         });
 
         return {

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

@@ -33,13 +33,11 @@ import { nls } from '@theia/core/lib/common/nls';
 
 export const HTTP_UPLOAD_URL: string = new Endpoint({ path: HTTP_FILE_UPLOAD_PATH }).getRestUrl().toString(true);
 
-export interface CustomDataTransfer {
-    values(): Iterable<CustomDataTransferItem>
-}
+export type CustomDataTransfer = Iterable<readonly [string, CustomDataTransferItem]>;
 
 export interface CustomDataTransferItem {
-    readonly id: string;
     asFile(): {
+        readonly id: string;
         readonly name: string;
         data(): Promise<Uint8Array>;
     } | undefined
@@ -420,10 +418,10 @@ export class FileUploadService {
     }
 
     protected async indexCustomDataTransfer(targetUri: URI, dataTransfer: CustomDataTransfer, context: FileUploadService.Context): Promise<void> {
-        for (const item of dataTransfer.values()) {
+        for (const [_, item] of dataTransfer) {
             const fileInfo = item.asFile();
             if (fileInfo) {
-                await this.indexFile(targetUri, new File([await fileInfo.data()], item.id), context);
+                await this.indexFile(targetUri, new File([await fileInfo.data()], fileInfo.id), context);
             }
         }
     }

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

@@ -14,27 +14,36 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable, inject } from '@theia/core/shared/inversify';
-import URI from '@theia/core/lib/common/uri';
-import { environment } from '@theia/core/shared/@theia/application-package/lib/environment';
-import { MaybePromise, SelectionService, isCancelled, Emitter } from '@theia/core/lib/common';
-import { Command, CommandContribution, CommandRegistry } from '@theia/core/lib/common/command';
+import { nls } from '@theia/core';
 import {
-    FrontendApplicationContribution, ApplicationShell,
-    NavigatableWidget, NavigatableWidgetOptions,
-    Saveable, WidgetManager, StatefulWidget, FrontendApplication, ExpandableTreeNode,
-    CorePreferences,
+    ApplicationShell,
     CommonCommands,
+    CorePreferences,
+    ExpandableTreeNode,
+    FrontendApplication,
+    FrontendApplicationContribution,
+    NavigatableWidget, NavigatableWidgetOptions,
+    OpenerService,
+    Saveable,
+    StatefulWidget,
+    WidgetManager,
+    open
 } from '@theia/core/lib/browser';
 import { MimeService } from '@theia/core/lib/browser/mime-service';
 import { TreeWidgetSelection } from '@theia/core/lib/browser/tree/tree-widget-selection';
-import { FileSystemPreferences } from './filesystem-preferences';
+import { Emitter, MaybePromise, SelectionService, isCancelled } from '@theia/core/lib/common';
+import { Command, CommandContribution, CommandRegistry } from '@theia/core/lib/common/command';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import URI from '@theia/core/lib/common/uri';
+import { environment } from '@theia/core/shared/@theia/application-package/lib/environment';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { UserWorkingDirectoryProvider } from '@theia/core/lib/browser/user-working-directory-provider';
+import { FileChangeType, FileChangesEvent, FileOperation } from '../common/files';
+import { FileDialogService, SaveFileDialogProps } from './file-dialog';
 import { FileSelection } from './file-selection';
-import { FileUploadService, FileUploadResult } from './file-upload-service';
 import { FileService, UserFileOperationEvent } from './file-service';
-import { FileChangesEvent, FileChangeType, FileOperation } from '../common/files';
-import { Deferred } from '@theia/core/lib/common/promise-util';
-import { nls } from '@theia/core';
+import { FileUploadResult, FileUploadService } from './file-upload-service';
+import { FileSystemPreferences } from './filesystem-preferences';
 
 export namespace FileSystemCommands {
 
@@ -78,6 +87,15 @@ export class FileSystemFrontendContribution implements FrontendApplicationContri
     @inject(FileService)
     protected readonly fileService: FileService;
 
+    @inject(FileDialogService)
+    protected readonly fileDialogService: FileDialogService;
+
+    @inject(OpenerService)
+    protected readonly openerService: OpenerService;
+
+    @inject(UserWorkingDirectoryProvider)
+    protected readonly workingDirectory: UserWorkingDirectoryProvider;
+
     protected onDidChangeEditorFileEmitter = new Emitter<{ editor: NavigatableWidget, type: FileChangeType }>();
     readonly onDidChangeEditorFile = this.onDidChangeEditorFileEmitter.event;
 
@@ -134,6 +152,11 @@ export class FileSystemFrontendContribution implements FrontendApplicationContri
                 }
             }
         });
+        commands.registerCommand(CommonCommands.NEW_FILE, {
+            execute: (...args: unknown[]) => {
+                this.handleNewFileCommand(args);
+            }
+        });
     }
 
     protected canUpload({ fileStat }: FileSelection): boolean {
@@ -155,6 +178,26 @@ export class FileSystemFrontendContribution implements FrontendApplicationContri
         }
     }
 
+    /**
+     * Opens a save dialog to create a new file.
+     *
+     * @param args The first argument is the name of the new file. The second argument is the parent directory URI.
+     */
+    protected async handleNewFileCommand(args: unknown[]): Promise<void> {
+        const fileName = (args !== undefined && typeof args[0] === 'string') ? args[0] : undefined;
+        const title = nls.localizeByDefault('Create File');
+        const props: SaveFileDialogProps = { title, saveLabel: title, inputValue: fileName };
+
+        const dirUri = (args[1] instanceof URI) ? args[1] : await this.workingDirectory.getUserWorkingDir();
+        const directory = await this.fileService.resolve(dirUri);
+
+        const filePath = await this.fileDialogService.showSaveDialog(props, directory.isDirectory ? directory : undefined);
+        if (filePath) {
+            const file = await this.fileService.createFile(filePath);
+            open(this.openerService, file.resource);
+        }
+    }
+
     protected getSelection(...args: unknown[]): FileSelection | undefined {
         const { selection } = this.selectionService;
         return this.toSelection(args[0]) ?? (Array.isArray(selection) ? selection.find(FileSelection.is) : this.toSelection(selection));

package/src/browser/filesystem-save-resource-service.ts

@@ -47,7 +47,7 @@ export class FilesystemSaveResourceService extends SaveResourceService {
     /**
      * Save `sourceWidget` to a new file picked by the user.
      */
-    override async saveAs(sourceWidget: Widget & SaveableSource & Navigatable, options?: SaveOptions): Promise<void> {
+    override async saveAs(sourceWidget: Widget & SaveableSource & Navigatable, options?: SaveOptions): Promise<URI | undefined> {
         let exist: boolean = false;
         let overwrite: boolean = false;
         let selected: URI | undefined;
@@ -68,10 +68,11 @@ export class FilesystemSaveResourceService extends SaveResourceService {
             }
         } while ((selected && exist && !overwrite) || (selected?.isEqual(uri) && !canSave));
         if (selected && selected.isEqual(uri)) {
-            await this.save(sourceWidget, options);
+            return this.save(sourceWidget, options);
         } else if (selected) {
             try {
                 await this.copyAndSave(sourceWidget, selected, overwrite);
+                return selected;
             } catch (e) {
                 console.warn(e);
             }

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

@@ -0,0 +1,38 @@
+// *****************************************************************************
+// 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 { ContainerModule } from '@theia/core/shared/inversify';
+import { FileSystemProvider } from '../common/files';
+import { BrowserFSFileSystemProvider } from './browserfs-filesystem-provider';
+import { RemoteFileSystemProvider, RemoteFileSystemServer } from '../common/remote-file-system-provider';
+import { BrowserFSInitialization, DefaultBrowserFSInitialization } from './browserfs-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);
+    if (isBound(FileSystemProvider)) {
+        rebind(FileSystemProvider).to(BrowserFSFileSystemProvider).inSingletonScope();
+    } else {
+        bind(FileSystemProvider).to(BrowserFSFileSystemProvider).inSingletonScope();
+    }
+    if (isBound(RemoteFileSystemProvider)) {
+        rebind(RemoteFileSystemServer).to(BrowserOnlyFileSystemProviderServer).inSingletonScope();
+    } else {
+        bind(RemoteFileSystemServer).to(BrowserOnlyFileSystemProviderServer).inSingletonScope();
+    }
+});

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

@@ -0,0 +1,32 @@
+// *****************************************************************************
+// 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 { injectable } from '@theia/core/shared/inversify';
+import { FileSystemProviderServer } from '../common/remote-file-system-provider';
+import { Event } from '@theia/core';
+
+/**
+ * Backend component.
+ *
+ * JSON-RPC server exposing a wrapped file system provider remotely.
+ */
+@injectable()
+export class BrowserOnlyFileSystemProviderServer extends FileSystemProviderServer {
+
+    // needed because users expect implicitly the RemoteFileSystemServer to be a RemoteFileSystemProxyFactory
+    onDidOpenConnection = Event.None;
+    onDidCloseConnection = Event.None;
+}

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

@@ -0,0 +1,61 @@
+// *****************************************************************************
+// 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 { FSModule } from 'browserfs/dist/node/core/FS';
+import type { BrowserFSFileSystemProvider } from './browserfs-filesystem-provider';
+import { injectable } from '@theia/core/shared/inversify';
+import { FileSystem, initialize } from 'browserfs';
+import MountableFileSystem from 'browserfs/dist/node/backend/MountableFileSystem';
+
+export const BrowserFSInitialization = Symbol('BrowserFSInitialization');
+export interface BrowserFSInitialization {
+    createMountableFileSystem(): Promise<MountableFileSystem>
+    initializeFS: (fs: FSModule, provider: BrowserFSFileSystemProvider) => Promise<void>;
+}
+
+@injectable()
+export class DefaultBrowserFSInitialization implements BrowserFSInitialization {
+
+    createMountableFileSystem(): Promise<MountableFileSystem> {
+        return new Promise(resolve => {
+            FileSystem.IndexedDB.Create({}, (e, persistedFS) => {
+                if (e) {
+                    throw e;
+                }
+                if (!persistedFS) {
+                    throw Error('Could not create filesystem');
+                }
+                FileSystem.MountableFileSystem.Create({
+                    '/home': persistedFS
+
+                }, (error, mountableFS) => {
+                    if (error) {
+                        throw error;
+                    }
+                    if (!mountableFS) {
+                        throw Error('Could not create filesystem');
+                    }
+                    initialize(mountableFS);
+                    resolve(mountableFS);
+                });
+            });
+        });
+    }
+
+    async initializeFS(fs: FSModule, provider: BrowserFSFileSystemProvider): Promise<void> {
+
+    }
+}