Switch from browserfs to OPFS

CHANGELOG.md

@@ -4,6 +4,14 @@
 
 - [Previous Changelogs](https://github.com/eclipse-theia/theia/tree/master/doc/changelogs/)
 
+<!--
+- ## 1.55.0 - XX/XX/2024
+
+<a name="breaking_changes_1.55.0">[Breaking Changes:](#breaking_changes_1.55.0)</a>
+- [dependencies] remove browserfs dependency (replaced by OPFS)
+
+-->
+
 ## 1.54.0 - 09/26/2024
 
 - [ai] add Theia AI LLM Support [Experimental] [#14048](https://github.com/eclipse-theia/theia/pull/14048)

examples/api-samples/src/browser-only/api-samples-frontend-only-module.ts

@@ -15,13 +15,13 @@
 // *****************************************************************************
 
 import { ContainerModule, interfaces } from '@theia/core/shared/inversify';
-import { bindBrowserFSInitialization } from './filesystem/example-filesystem-initialization';
+import { bindOPFSInitialization } from './filesystem/example-filesystem-initialization';
 
 export default new ContainerModule((
     bind: interfaces.Bind,
     _unbind: interfaces.Unbind,
     _isBound: interfaces.IsBound,
     rebind: interfaces.Rebind,
 ) => {
-    bindBrowserFSInitialization(bind, rebind);
+    bindOPFSInitialization(bind, rebind);
 });

examples/api-samples/src/browser-only/filesystem/example-filesystem-initialization.ts

@@ -17,35 +17,40 @@
 import { URI } from '@theia/core';
 import { inject, injectable, interfaces } from '@theia/core/shared/inversify';
 import { EncodingService } from '@theia/core/lib/common/encoding-service';
-import { BrowserFSInitialization, DefaultBrowserFSInitialization } from '@theia/filesystem/lib/browser-only/browserfs-filesystem-initialization';
-import { BrowserFSFileSystemProvider } from '@theia/filesystem/lib/browser-only/browserfs-filesystem-provider';
-import type { FSModule } from 'browserfs/dist/node/core/FS';
+import { OPFSInitialization, DefaultOPFSInitialization } from '@theia/filesystem/lib/browser-only/opfs-filesystem-initialization';
+import { OPFSFileSystemProvider } from '@theia/filesystem/lib/browser-only/opfs-filesystem-provider';
 
 @injectable()
-export class ExampleBrowserFSInitialization extends DefaultBrowserFSInitialization {
+export class ExampleOPFSInitialization extends DefaultOPFSInitialization {
 
     @inject(EncodingService)
     protected encodingService: EncodingService;
 
-    override async initializeFS(fs: FSModule, provider: BrowserFSFileSystemProvider): Promise<void> {
+    override async initializeFS(dir: FileSystemDirectoryHandle, provider: OPFSFileSystemProvider): Promise<void> {
         try {
-            if (!fs.existsSync('/home/workspace')) {
+            // Check whether the directory exists
+            try {
+                await provider.readdir(new URI('/home/workspace'));
+            } catch (e) {
+                console.error('An error occurred while reading the demo workspaces', e);
                 await provider.mkdir(new URI('/home/workspace'));
                 await provider.writeFile(new URI('/home/workspace/my-file.txt'), this.encodingService.encode('foo').buffer, { create: true, overwrite: false });
-                await provider.writeFile(new URI('/home/workspace/my-file2.txt'), this.encodingService.encode('bar').buffer, { create: true, overwrite: false });
             }
-            if (!fs.existsSync('/home/workspace2')) {
+
+            try {
+                await provider.readdir(new URI('/home/workspace2'));
+            } catch (e) {
+                console.error('An error occurred while reading the demo workspaces', e);
                 await provider.mkdir(new URI('/home/workspace2'));
                 await provider.writeFile(new URI('/home/workspace2/my-file.json'), this.encodingService.encode('{ foo: true }').buffer, { create: true, overwrite: false });
-                await provider.writeFile(new URI('/home/workspace2/my-file2.json'), this.encodingService.encode('{ bar: false }').buffer, { create: true, overwrite: false });
             }
         } catch (e) {
             console.error('An error occurred while initializing the demo workspaces', e);
         }
     }
 }
 
-export const bindBrowserFSInitialization = (bind: interfaces.Bind, rebind: interfaces.Rebind): void => {
-    bind(ExampleBrowserFSInitialization).toSelf();
-    rebind(BrowserFSInitialization).toService(ExampleBrowserFSInitialization);
+export const bindOPFSInitialization = (bind: interfaces.Bind, rebind: interfaces.Rebind): void => {
+    bind(ExampleOPFSInitialization).toSelf();
+    rebind(OPFSInitialization).toService(ExampleOPFSInitialization);
 };

packages/filesystem/package.json

@@ -10,7 +10,6 @@
     "@types/tar-fs": "^1.16.1",
     "async-mutex": "^0.3.1",
     "body-parser": "^1.18.3",
-    "browserfs": "^1.4.3",
     "http-status-codes": "^1.3.0",
     "minimatch": "^5.1.0",
     "multer": "1.4.4-lts.1",

packages/filesystem/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();