Function createBlobReaderIterable

lib/internal/blob.js:538–600

(reader, options = kEmptyObject)

const kMaxBatchChunks = 16;

async function* createBlobReaderIterable(reader, options = kEmptyObject) {
  const { getReadError } = options;
  let wakeup = PromiseWithResolvers();
  reader.setWakeup(wakeup.resolve);

  try {
    while (true) {
      const batch = [];
      let blocked = false;
      let eos = false;
      let error = null;

      // Pull as many chunks as available synchronously.
      // reader.pull(callback) calls the callback synchronously via
      // MakeCallback, so we can collect multiple chunks per iteration
      // step without any async overhead.
      while (true) {
        let pullResult;
        reader.pull((status, buffer) => {
          pullResult = { status, buffer };
        });

        if (pullResult.status === 0) {
          eos = true;
          break;
        }
        if (pullResult.status < 0) {
          error = typeof getReadError === 'function' ?
            getReadError(pullResult.status) :
            new ERR_INVALID_STATE('The reader is not readable');
          break;
        }
        if (pullResult.status === 2) {
          blocked = true;
          break;
        }
        ArrayPrototypePush(batch, new Uint8Array(pullResult.buffer));
        if (batch.length >= kMaxBatchChunks) break;
      }

      if (batch.length > 0) {
        yield batch;
      }

      if (eos) return;
      if (error) throw error;

      if (blocked) {
        const fin = await wakeup.promise;
        wakeup = PromiseWithResolvers();
        reader.setWakeup(wakeup.resolve);
        // If the wakeup was triggered by FIN (EndReadable), the DataQueue
        // is capped. Continue the loop to pull again -- the next pull will
        // return EOS. Without this, a race between the data notification
        // and the FIN notification can leave the iterator waiting for a
        // wakeup that will never come.
        if (fin) continue;
      }