feat: align openAsBlob errors with Node.js behavior

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

Author: Copilot

src/fsa-to-node/FsaNodeFs.ts

@@ -17,6 +17,7 @@ import { FsaNodeReadStream } from './FsaNodeReadStream';
 import { FsaNodeCore } from './FsaNodeCore';
 import { FileHandle } from '../node/FileHandle';
 import { dataToBuffer, isFd, isWin, validateFd } from '../core/util';
+import * as errors from '../vendor/node/internal/errors';
 import type { FsCallbackApi, FsPromisesApi } from '../node/types';
 import type * as misc from '../node/types/misc';
 import type * as opts from '../node/types/options';
@@ -792,12 +793,22 @@ export class FsaNodeFs extends FsaNodeCore implements FsCallbackApi, FsSynchrono
   };
 
   public openAsBlob = async (path: misc.PathLike, options?: opts.IOpenAsBlobOptions): Promise<Blob> => {
-    const buffer = await new Promise<Buffer>((resolve, reject) => {
-      this.readFile(path, (err, data: Buffer) => {
-        if (err) reject(err);
-        else resolve(data);
+    let buffer;
+    try {
+      buffer = await new Promise<Buffer>((resolve, reject) => {
+        this.readFile(path, (err, data: Buffer) => {
+          if (err) reject(err);
+          else resolve(data);
+        });
       });
-    });
+    } catch (error) {
+      // Convert ENOENT to Node.js-compatible error for openAsBlob
+      if (error && typeof error === 'object' && error.code === 'ENOENT') {
+        const nodeError = new errors.TypeError('ERR_INVALID_ARG_VALUE');
+        throw nodeError;
+      }
+      throw error;
+    }
     const type = options?.type || '';
     return new Blob([buffer as BlobPart], { type });
   };

src/fsa-to-node/__tests__/FsaNodeFs.test.ts

@@ -303,6 +303,18 @@ onlyOnNode20('FsaNodeFs', () => {
       const blob = await fs.openAsBlob('/folder/file');
       expect(await blob.text()).toBe('test');
     });
+
+    test('throws TypeError with ERR_INVALID_ARG_VALUE for non-existing files', async () => {
+      const { fs } = setup({ folder: { file: 'test' }, 'empty-folder': null });
+      try {
+        await fs.openAsBlob('/nonexistent');
+        throw new Error('Expected error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(TypeError);
+        expect(error.code).toBe('ERR_INVALID_ARG_VALUE');
+        expect(error.message).toContain('Unable to open file as blob');
+      }
+    });
   });
 
   describe('.truncate()', () => {

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

@@ -48,15 +48,17 @@ describe('.openAsBlob()', () => {
   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');
+    expect(err).toBeInstanceOf(TypeError);
+    expect((<any>err).code).toBe('ERR_INVALID_ARG_VALUE');
+    expect((<any>err).message).toContain('Unable to open file as blob');
   });
 
-  it('throws EISDIR if path is a directory', async () => {
+  it('allows opening directories as blobs like Node.js', 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');
+    const blob = await fs.openAsBlob('/dir');
+    expect(blob).toBeInstanceOf(Blob);
+    // Directory "content" size may vary, but it should be a valid blob
+    expect(typeof blob.size).toBe('number');
   });
 
   it('works with Buffer paths', async () => {

src/node/volume.ts

@@ -19,6 +19,7 @@ import { FsCallbackApi, WritevCallback } from './types/FsCallbackApi';
 import { FsPromises } from './FsPromises';
 import { ToTreeOptions, toTreeSync } from '../print';
 import { ERRSTR, FLAGS, MODE } from './constants';
+import * as errors from '../vendor/node/internal/errors';
 import {
   getDefaultOpts,
   getDefaultOptsAndCb,
@@ -1489,9 +1490,20 @@ export class Volume implements FsCallbackApi, FsSynchronousApi {
 
   public openAsBlob = async (path: PathLike, options?: opts.IOpenAsBlobOptions): Promise<Blob> => {
     const filename = pathToFilename(path);
-    const link = this._core.getResolvedLinkOrThrow(filename, 'open');
+    let link;
+    try {
+      link = this._core.getResolvedLinkOrThrow(filename, 'open');
+    } catch (error) {
+      // Convert ENOENT to Node.js-compatible error for openAsBlob
+      if (error && typeof error === 'object' && error.code === 'ENOENT') {
+        const nodeError = new errors.TypeError('ERR_INVALID_ARG_VALUE');
+        throw nodeError;
+      }
+      throw error;
+    }
+
     const node = link.getNode();
-    if (node.isDirectory()) throw createError(ERROR_CODE.EISDIR, 'open', link.getPath());
+    // Note: Node.js allows opening directories as blobs, so we don't throw EISDIR
 
     const buffer = node.getBuffer();
     const type = options?.type || '';

src/vendor/node/internal/errors.ts

@@ -86,3 +86,4 @@ E('ERR_INVALID_OPT_VALUE', (name, value) => {
   return `The value "${String(value)}" is invalid for option "${name}"`;
 });
 E('ERR_INVALID_OPT_VALUE_ENCODING', value => `The value "${String(value)}" is invalid for option "encoding"`);
+E('ERR_INVALID_ARG_VALUE', 'Unable to open file as blob');