feat: implement fs.openAsBlob method with comprehensive tests

Co-authored-by: streamich <[email protected]>

Author: Copilot

src/node/__tests__/volume/openAsBlob.test.ts

@@ -0,0 +1,102 @@
+import { of } from '../../../thingies';
+import { memfs } from '../../../';
+
+describe('.openAsBlob()', () => {
+  it('can read a text file as blob', async () => {
+    const { fs } = memfs({ '/dir/test.txt': 'Hello, World!' });
+    const blob = await fs.openAsBlob('/dir/test.txt');
+    expect(blob).toBeInstanceOf(Blob);
+    expect(blob.size).toBe(13);
+    expect(blob.type).toBe('');
+
+    const text = await blob.text();
+    expect(text).toBe('Hello, World!');
+  });
+
+  it('can read a binary file as blob', async () => {
+    const binaryData = Buffer.from([0x89, 0x50, 0x4e, 0x47]); // PNG header
+    const { fs } = memfs({ '/image.png': binaryData });
+    const blob = await fs.openAsBlob('/image.png');
+    expect(blob).toBeInstanceOf(Blob);
+    expect(blob.size).toBe(4);
+
+    const arrayBuffer = await blob.arrayBuffer();
+    const view = new Uint8Array(arrayBuffer);
+    expect(Array.from(view)).toEqual([0x89, 0x50, 0x4e, 0x47]);
+  });
+
+  it('can specify a mime type', async () => {
+    const { fs } = memfs({ '/data.json': '{"key": "value"}' });
+    const blob = await fs.openAsBlob('/data.json', { type: 'application/json' });
+    expect(blob).toBeInstanceOf(Blob);
+    expect(blob.type).toBe('application/json');
+
+    const text = await blob.text();
+    expect(text).toBe('{"key": "value"}');
+  });
+
+  it('handles empty files', async () => {
+    const { fs } = memfs({ '/empty.txt': '' });
+    const blob = await fs.openAsBlob('/empty.txt');
+    expect(blob).toBeInstanceOf(Blob);
+    expect(blob.size).toBe(0);
+
+    const text = await blob.text();
+    expect(text).toBe('');
+  });
+
+  it('throws if file does not exist', async () => {
+    const { fs } = memfs({ '/dir/test.txt': 'content' });
+    const [, err] = await of(fs.openAsBlob('/dir/test-NOT-FOUND.txt'));
+    expect(err).toBeInstanceOf(Error);
+    expect((<any>err).code).toBe('ENOENT');
+  });
+
+  it('throws EISDIR if path is a directory', async () => {
+    const { fs } = memfs({ '/dir/test.txt': 'content' });
+    const [, err] = await of(fs.openAsBlob('/dir'));
+    expect(err).toBeInstanceOf(Error);
+    expect((<any>err).code).toBe('EISDIR');
+  });
+
+  it('works with Buffer paths', async () => {
+    const { fs } = memfs({ '/test.txt': 'buffer path test' });
+    const pathBuffer = Buffer.from('/test.txt');
+    const blob = await fs.openAsBlob(pathBuffer);
+    expect(blob).toBeInstanceOf(Blob);
+
+    const text = await blob.text();
+    expect(text).toBe('buffer path test');
+  });
+
+  it('works with different path formats', async () => {
+    const { fs } = memfs({ '/path-test.txt': 'path format test' });
+    const blob = await fs.openAsBlob('/path-test.txt');
+    expect(blob).toBeInstanceOf(Blob);
+
+    const text = await blob.text();
+    expect(text).toBe('path format test');
+  });
+
+  it('handles large files', async () => {
+    const largeContent = 'x'.repeat(10000);
+    const { fs } = memfs({ '/large.txt': largeContent });
+    const blob = await fs.openAsBlob('/large.txt');
+    expect(blob).toBeInstanceOf(Blob);
+    expect(blob.size).toBe(10000);
+
+    const text = await blob.text();
+    expect(text).toBe(largeContent);
+  });
+
+  it('can read file through symlink', async () => {
+    const { fs } = memfs({ '/original.txt': 'symlink test' });
+    fs.symlinkSync('/original.txt', '/link.txt');
+
+    const blob = await fs.openAsBlob('/link.txt');
+    expect(blob).toBeInstanceOf(Blob);
+
+    const text = await blob.text();
+    expect(text).toBe('symlink test');
+  });
+});

src/node/lists/fsCallbackApiList.ts

@@ -7,6 +7,7 @@ export const fsCallbackApiList: Array<keyof FsCallbackApi> = [
   'chown',
   'close',
   'copyFile',
+  'cp',
   'createReadStream',
   'createWriteStream',
   'exists',
@@ -24,6 +25,7 @@ export const fsCallbackApiList: Array<keyof FsCallbackApi> = [
   'mkdir',
   'mkdtemp',
   'open',
+  'openAsBlob',
   'opendir',
   'read',
   'readv',
@@ -35,6 +37,7 @@ export const fsCallbackApiList: Array<keyof FsCallbackApi> = [
   'rm',
   'rmdir',
   'stat',
+  'statfs',
   'symlink',
   'truncate',
   'unlink',

src/node/volume.ts

@@ -1446,8 +1446,28 @@ export class Volume implements FsCallbackApi, FsSynchronousApi {
   public statfsSync: FsSynchronousApi['statfsSync'] = notImplemented;
   /** @todo Implement statfs */
   public statfs: FsCallbackApi['statfs'] = notImplemented;
-  /** @todo Implement openAsBlob */
-  public openAsBlob: FsCallbackApi['openAsBlob'] = notImplemented;
+  private readonly _openAsBlob = (filename: string, options: opts.IOpenAsBlobOptions = {}): Blob => {
+    const link = this._core.getResolvedLinkOrThrow(filename, 'open');
+    const node = link.getNode();
+    if (node.isDirectory()) throw createError(ERROR_CODE.EISDIR, 'open', link.getPath());
+
+    const buffer = node.getBuffer();
+    const type = options.type || '';
+
+    return new Blob([buffer], { type });
+  };
+
+  public openAsBlob = (path: PathLike, options?: opts.IOpenAsBlobOptions): Promise<Blob> => {
+    return new Promise((resolve, reject) => {
+      try {
+        const filename = pathToFilename(path);
+        const blob = this._openAsBlob(filename, options);
+        resolve(blob);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  };
 
   private readonly _opendir = (filename: string, options: opts.IOpendirOptions): Dir => {
     const link: Link = this._core.getResolvedLinkOrThrow(filename, 'scandir');