Function fromReadable

lib/internal/streams/iter/classic.js:210–244

* Convert a classic Readable (or duck-type) to a stream/iter async iterable. * * If the object implements the toAsyncStreamable protocol, delegates to it. * Otherwise, duck-type checks for read() + EventEmitter (on/off) and * wraps with a batched async iterator. * @param {object} readable - A c

(readable)

 * @returns {AsyncIterable<Uint8Array[]>} A stream/iter async iterable source.
 */
function fromReadable(readable) {
  if (readable == null || typeof readable !== 'object') {
    throw new ERR_INVALID_ARG_TYPE('readable', 'Readable', readable);
  }

  // Check cache first.
  const cached = fromReadableCache.get(readable);
  if (cached !== undefined) return cached;

  // Protocol path: object implements toAsyncStreamable.
  if (typeof readable[kToAsyncStreamable] === 'function') {
    const result = readable[kToAsyncStreamable]();
    fromReadableCache.set(readable, result);
    return result;
  }

  // Duck-type path: object has read() and EventEmitter methods.
  if (typeof readable.read !== 'function' ||
      typeof readable.on !== 'function') {
    throw new ERR_INVALID_ARG_TYPE('readable', 'Readable', readable);
  }

  // Determine normalization. If the stream has _readableState, use it
  // to detect object-mode / encoding. Otherwise assume byte-mode.
  const state = readable._readableState;
  const normalize = (state && (state.objectMode || state.encoding)) ?
    normalizeBatch : null;

  const iter = createBatchedAsyncIterator(readable, normalize);
  iter[kValidatedSource] = true;
  iter.stream = readable;

  fromReadableCache.set(readable, iter);
  return iter;
}


// ============================================================================