nodejs · nodejs-github-bot · Sep 26, 2024 · Jun 6, 2024
diff --git a/lib/internal/blob.js b/lib/internal/blob.js
@@ -273,54 +273,32 @@ class Blob {
    if (!isBlob(this))
      return PromiseReject(new ERR_INVALID_THIS('Blob'));

-    const { promise, resolve, reject } = createDeferredPromise();
-    const reader = this[kHandle].getReader();
-    const buffers = [];
-    const readNext = () => {
-      reader.pull((status, buffer) => {
-        if (status === 0) {
-          // EOS, concat & resolve
-          // buffer should be undefined here
-          resolve(concat(buffers));
-          return;
-        } else if (status < 0) {
-          // The read could fail for many different reasons when reading
-          // from a non-memory resident blob part (e.g. file-backed blob).
-          // The error details the system error code.
-          const error = lazyDOMException('The blob could not be read', 'NotReadableError');
-          reject(error);
-          return;
-        }
-        if (buffer !== undefined)
-          buffers.push(buffer);
-        queueMicrotask(() => readNext());
-      });
-    };
-    readNext();
-    return promise;
+    return arrayBuffer(this);
  }

  /**
   * @returns {Promise<string>}
   */
-  async text() {
+  text() {
    if (!isBlob(this))
-      throw new ERR_INVALID_THIS('Blob');
+      return PromiseReject(new ERR_INVALID_THIS('Blob'));

    dec ??= new TextDecoder();

-    return dec.decode(await this.arrayBuffer());
+    return PromisePrototypeThen(
+      arrayBuffer(this),
+      (buffer) => dec.decode(buffer));
  }

  /**
   * @returns {Promise<Uint8Array>}
   */
  bytes() {
    if (!isBlob(this))
-      throw new ERR_INVALID_THIS('Blob');
+      return PromiseReject(new ERR_INVALID_THIS('Blob'));

    return PromisePrototypeThen(
-      this.arrayBuffer(),
+      arrayBuffer(this),
      (buffer) => new Uint8Array(buffer));
  }

@@ -439,6 +417,7 @@ ObjectDefineProperties(Blob.prototype, {
  stream: kEnumerableProperty,
  text: kEnumerableProperty,
  arrayBuffer: kEnumerableProperty,
+  bytes: kEnumerableProperty,
 });

 function resolveObjectURL(url) {
@@ -490,6 +469,34 @@ function createBlobFromFilePath(path, options) {
  return res;
 }

+function arrayBuffer(blob) {
+  const { promise, resolve, reject } = createDeferredPromise();
+  const reader = blob[kHandle].getReader();
+  const buffers = [];
+  const readNext = () => {
+    reader.pull((status, buffer) => {
+      if (status === 0) {
+        // EOS, concat & resolve
+        // buffer should be undefined here
+        resolve(concat(buffers));
+        return;
+      } else if (status < 0) {
+        // The read could fail for many different reasons when reading
+        // from a non-memory resident blob part (e.g. file-backed blob).
+        // The error details the system error code.
+        const error = lazyDOMException('The blob could not be read', 'NotReadableError');
+        reject(error);
+        return;
+      }
+      if (buffer !== undefined)
+        buffers.push(buffer);
+      queueMicrotask(() => readNext());
+    });
+  };
+  readNext();
+  return promise;
+}
+
 module.exports = {
  Blob,
  createBlob,

diff --git a/test/parallel/test-blob.js b/test/parallel/test-blob.js
@@ -197,6 +197,7 @@ assert.throws(() => new Blob({}), {
    'stream',
    'text',
    'arrayBuffer',
+    'bytes',
  ];

  for (const prop of enumerable) {
@@ -409,10 +410,13 @@ assert.throws(() => new Blob({}), {
 }

 (async () => {
-  await assert.rejects(async () => Blob.prototype.arrayBuffer.call(), {
+  await assert.rejects(() => Blob.prototype.arrayBuffer.call(), {
    code: 'ERR_INVALID_THIS',
  });
-  await assert.rejects(async () => Blob.prototype.text.call(), {
+  await assert.rejects(() => Blob.prototype.text.call(), {
+    code: 'ERR_INVALID_THIS',
+  });
+  await assert.rejects(() => Blob.prototype.bytes.call(), {
    code: 'ERR_INVALID_THIS',
  });
 })().then(common.mustCall());
@@ -490,3 +494,16 @@ assert.throws(() => new Blob({}), {
  assert.ok(structuredClone(blob).size === blob.size);
  assert.ok((await structuredClone(blob).text()) === (await blob.text()));
 })().then(common.mustCall());
+
+(async () => {
+  const blob = new Blob(['hello']);
+  const { arrayBuffer } = Blob.prototype;
+
+  Blob.prototype.arrayBuffer = common.mustNotCall();
+
+  try {
+    assert.strictEqual(await blob.text(), 'hello');
+  } finally {
+    Blob.prototype.arrayBuffer = arrayBuffer;
+  }
+})().then(common.mustCall());