@theia/filesystem 1.55.1 → 1.57.0-next.7

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-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,347 @@
+// *****************************************************************************
+// 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 createFileSystemProviderError(`Error while accessing resource ${resource.toString()}`, FileSystemProviderErrorCode.Unknown);
+        }
+    }
+
+    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 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 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/lib/browser-only/browserfs-filesystem-initialization.d.ts

@@ -1,13 +0,0 @@
-import type { FSModule } from 'browserfs/dist/node/core/FS';
-import type { BrowserFSFileSystemProvider } from './browserfs-filesystem-provider';
-import MountableFileSystem from 'browserfs/dist/node/backend/MountableFileSystem';
-export declare const BrowserFSInitialization: unique symbol;
-export interface BrowserFSInitialization {
-    createMountableFileSystem(): Promise<MountableFileSystem>;
-    initializeFS: (fs: FSModule, provider: BrowserFSFileSystemProvider) => Promise<void>;
-}
-export declare class DefaultBrowserFSInitialization implements BrowserFSInitialization {
-    createMountableFileSystem(): Promise<MountableFileSystem>;
-    initializeFS(fs: FSModule, provider: BrowserFSFileSystemProvider): Promise<void>;
-}
-//# sourceMappingURL=browserfs-filesystem-initialization.d.ts.map

package/lib/browser-only/browserfs-filesystem-initialization.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"browserfs-filesystem-initialization.d.ts","sourceRoot":"","sources":["../../src/browser-only/browserfs-filesystem-initialization.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AAGnF,OAAO,mBAAmB,MAAM,iDAAiD,CAAC;AAElF,eAAO,MAAM,uBAAuB,eAAoC,CAAC;AACzE,MAAM,WAAW,uBAAuB;IACpC,yBAAyB,IAAI,OAAO,CAAC,mBAAmB,CAAC,CAAA;IACzD,YAAY,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,2BAA2B,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACxF;AAED,qBACa,8BAA+B,YAAW,uBAAuB;IAE1E,yBAAyB,IAAI,OAAO,CAAC,mBAAmB,CAAC;IA0BnD,YAAY,CAAC,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,2BAA2B,GAAG,OAAO,CAAC,IAAI,CAAC;CAGzF"}

package/lib/browser-only/browserfs-filesystem-initialization.js

@@ -1,55 +0,0 @@
-"use strict";
-// *****************************************************************************
-// 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
-// *****************************************************************************
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultBrowserFSInitialization = exports.BrowserFSInitialization = void 0;
-const tslib_1 = require("tslib");
-const inversify_1 = require("@theia/core/shared/inversify");
-const browserfs_1 = require("browserfs");
-exports.BrowserFSInitialization = Symbol('BrowserFSInitialization');
-let DefaultBrowserFSInitialization = class DefaultBrowserFSInitialization {
-    createMountableFileSystem() {
-        return new Promise(resolve => {
-            browserfs_1.FileSystem.IndexedDB.Create({}, (e, persistedFS) => {
-                if (e) {
-                    throw e;
-                }
-                if (!persistedFS) {
-                    throw Error('Could not create filesystem');
-                }
-                browserfs_1.FileSystem.MountableFileSystem.Create({
-                    '/home': persistedFS
-                }, (error, mountableFS) => {
-                    if (error) {
-                        throw error;
-                    }
-                    if (!mountableFS) {
-                        throw Error('Could not create filesystem');
-                    }
-                    (0, browserfs_1.initialize)(mountableFS);
-                    resolve(mountableFS);
-                });
-            });
-        });
-    }
-    async initializeFS(fs, provider) {
-    }
-};
-exports.DefaultBrowserFSInitialization = DefaultBrowserFSInitialization;
-exports.DefaultBrowserFSInitialization = DefaultBrowserFSInitialization = tslib_1.__decorate([
-    (0, inversify_1.injectable)()
-], DefaultBrowserFSInitialization);
-//# sourceMappingURL=browserfs-filesystem-initialization.js.map

package/lib/browser-only/browserfs-filesystem-initialization.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"browserfs-filesystem-initialization.js","sourceRoot":"","sources":["../../src/browser-only/browserfs-filesystem-initialization.ts"],"names":[],"mappings":";AAAA,gFAAgF;AAChF,+CAA+C;AAC/C,EAAE;AACF,2EAA2E;AAC3E,mEAAmE;AACnE,wCAAwC;AACxC,EAAE;AACF,4EAA4E;AAC5E,8EAA8E;AAC9E,6EAA6E;AAC7E,yDAAyD;AACzD,uDAAuD;AACvD,EAAE;AACF,gFAAgF;AAChF,gFAAgF;;;;AAIhF,4DAA0D;AAC1D,yCAAmD;AAGtC,QAAA,uBAAuB,GAAG,MAAM,CAAC,yBAAyB,CAAC,CAAC;AAOlE,IAAM,8BAA8B,GAApC,MAAM,8BAA8B;IAEvC,yBAAyB;QACrB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;YACzB,sBAAU,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,WAAW,EAAE,EAAE;gBAC/C,IAAI,CAAC,EAAE,CAAC;oBACJ,MAAM,CAAC,CAAC;gBACZ,CAAC;gBACD,IAAI,CAAC,WAAW,EAAE,CAAC;oBACf,MAAM,KAAK,CAAC,6BAA6B,CAAC,CAAC;gBAC/C,CAAC;gBACD,sBAAU,CAAC,mBAAmB,CAAC,MAAM,CAAC;oBAClC,OAAO,EAAE,WAAW;iBAEvB,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE;oBACtB,IAAI,KAAK,EAAE,CAAC;wBACR,MAAM,KAAK,CAAC;oBAChB,CAAC;oBACD,IAAI,CAAC,WAAW,EAAE,CAAC;wBACf,MAAM,KAAK,CAAC,6BAA6B,CAAC,CAAC;oBAC/C,CAAC;oBACD,IAAA,sBAAU,EAAC,WAAW,CAAC,CAAC;oBACxB,OAAO,CAAC,WAAW,CAAC,CAAC;gBACzB,CAAC,CAAC,CAAC;YACP,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACP,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,EAAY,EAAE,QAAqC;IAEtE,CAAC;CACJ,CAAA;AA/BY,wEAA8B;yCAA9B,8BAA8B;IAD1C,IAAA,sBAAU,GAAE;GACA,8BAA8B,CA+B1C"}

package/lib/browser-only/browserfs-filesystem-provider.d.ts

@@ -1,46 +0,0 @@
-import { FileChange, FileDeleteOptions, FileOpenOptions, FileOverwriteOptions, FileReadStreamOptions, FileSystemProviderCapabilities, FileSystemProviderWithFileReadWriteCapability, FileType, FileUpdateOptions, FileUpdateResult, FileWriteOptions, Stat, WatchOptions } from '../common/files';
-import { Event, URI, Disposable, CancellationToken } from '@theia/core';
-import { TextDocumentContentChangeEvent } from '@theia/core/shared/vscode-languageserver-protocol';
-import { ReadableStreamEvents } from '@theia/core/lib/common/stream';
-import type { FileSystem } from 'browserfs/dist/node/core/file_system';
-import { BrowserFSInitialization } from './browserfs-filesystem-initialization';
-export declare class BrowserFSFileSystemProvider implements FileSystemProviderWithFileReadWriteCapability {
-    readonly initialization: BrowserFSInitialization;
-    capabilities: FileSystemProviderCapabilities;
-    onDidChangeCapabilities: Event<void>;
-    onDidChangeFile: Event<readonly FileChange[]>;
-    onFileWatchError: Event<void>;
-    private mapHandleToPos;
-    private writeHandles;
-    private canFlush;
-    private fs;
-    private mountableFS;
-    private initialized;
-    constructor(initialization: BrowserFSInitialization);
-    mount(mountPoint: string, fs: FileSystem): Promise<void>;
-    watch(_resource: URI, _opts: WatchOptions): Disposable;
-    stat(resource: URI): Promise<Stat>;
-    mkdir(resource: URI): Promise<void>;
-    readdir(resource: URI): Promise<[string, FileType][]>;
-    delete(resource: URI, _opts: FileDeleteOptions): Promise<void>;
-    rename(from: URI, to: URI, opts: FileOverwriteOptions): Promise<void>;
-    copy?(from: URI, to: URI, opts: FileOverwriteOptions): Promise<void>;
-    readFile(resource: URI): Promise<Uint8Array>;
-    writeFile(resource: URI, content: Uint8Array, opts: FileWriteOptions): Promise<void>;
-    readFileStream?(resource: URI, opts: FileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
-    open(resource: URI, opts: FileOpenOptions): Promise<number>;
-    close(fd: number): Promise<void>;
-    read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
-    write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
-    private doWrite;
-    private normalizePos;
-    private updatePos;
-    access?(resource: URI, mode?: number | undefined): Promise<void>;
-    fsPath?(resource: URI): Promise<string>;
-    updateFile?(resource: URI, changes: TextDocumentContentChangeEvent[], opts: FileUpdateOptions): Promise<FileUpdateResult>;
-    private toFilePath;
-    private toType;
-    private promisify;
-    private toFileSystemProviderError;
-}
-//# sourceMappingURL=browserfs-filesystem-provider.d.ts.map

package/lib/browser-only/browserfs-filesystem-provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"browserfs-filesystem-provider.d.ts","sourceRoot":"","sources":["../../src/browser-only/browserfs-filesystem-provider.ts"],"names":[],"mappings":"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"}