Node.js module

stream/web

The 'node:stream/web' submodule implements WHATWG Streams API interfaces (ReadableStream, WritableStream) in Node.js, aligning with browser stream standards.

This allows interoperation between web-standard and Node-native streams in modern applications.

const ByteLengthQueuingStrategy: new (init: QueuingStrategyInit) => ByteLengthQueuingStrategy
const CompressionStream: new (format: CompressionFormat) => CompressionStream
const CountQueuingStrategy: new (init: QueuingStrategyInit) => CountQueuingStrategy
const DecompressionStream: new (format: CompressionFormat) => DecompressionStream
const ReadableByteStreamController: new () => ReadableByteStreamController
const ReadableStream: {new (underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark: number }) => ReadableStream<NonSharedUint8Array>; new (underlyingSource: UnderlyingDefaultSource<R>, strategy?: QueuingStrategy<R>) => ReadableStream<R>; new (underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>) => ReadableStream<R>}
const ReadableStreamBYOBReader: new (stream: ReadableStream<NonSharedUint8Array>) => ReadableStreamBYOBReader
const ReadableStreamBYOBRequest: new () => ReadableStreamBYOBRequest
const ReadableStreamDefaultController: new () => ReadableStreamDefaultController
const ReadableStreamDefaultReader: new (stream: ReadableStream<R>) => ReadableStreamDefaultReader<R>
const TextDecoderStream: new (label?: string, options?: TextDecoderOptions) => TextDecoderStream
const TextEncoderStream: new () => TextEncoderStream
const TransformStream: new (transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>) => TransformStream<I, O>
const TransformStreamDefaultController: new () => TransformStreamDefaultController
const WritableStream: new (underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>) => WritableStream<W>
const WritableStreamDefaultController: new () => WritableStreamDefaultController
const WritableStreamDefaultWriter: new (stream: WritableStream<W>) => WritableStreamDefaultWriter<W>

Type definitions

interface ByteLengthQueuingStrategy
- readonly highWaterMark: number
- readonly size: QueuingStrategySize<ArrayBufferView<ArrayBufferLike>>
interface CompressionStream
- readonly readable: ReadableStream<NonSharedUint8Array>
- readonly writable: WritableStream<BufferSource>
interface CountQueuingStrategy
- readonly highWaterMark: number
- readonly size: QueuingStrategySize
interface DecompressionStream
- readonly readable: ReadableStream<NonSharedUint8Array>
- readonly writable: WritableStream<BufferSource>
interface GenericTransformStream
- readonly readable: ReadableStream
- readonly writable: WritableStream
interface QueuingStrategy<T = any>
- highWaterMark?: number
- size?: QueuingStrategySize<T>
interface QueuingStrategyInit
- highWaterMark: number
interface QueuingStrategySize<T = any>
interface ReadableByteStreamController
- readonly byobRequest: null | ReadableStreamBYOBRequest
- readonly desiredSize: null | number
- close(): void;
- enqueue(
  chunk: NonSharedArrayBufferView
  ): void;
- error(
  e?: any
  ): void;
interface ReadableStream<R = any>
- readonly locked: boolean
- cancel(
  reason?: any
  ): Promise<void>;
- getReader(
  options: { mode: 'byob' }
  ): ReadableStreamBYOBReader;
  getReader(): ReadableStreamDefaultReader<R>;
  getReader(
  options?: ReadableStreamGetReaderOptions
  ): ReadableStreamReader<R>;
- pipeThrough<T>(
  transform: ReadableWritablePair<T, R>,
  options?: StreamPipeOptions
  ): ReadableStream<T>;
- pipeTo(
  destination: WritableStream<R>,
  options?: StreamPipeOptions
  ): Promise<void>;
- tee(): [ReadableStream<R>, ReadableStream<R>];
- values(
  options?: ReadableStreamIteratorOptions
  ): ReadableStreamAsyncIterator<R>;
interface ReadableStreamAsyncIterator<T>
- [Symbol.asyncDispose](): PromiseLike<void>;
- [Symbol.asyncIterator](): ReadableStreamAsyncIterator<T>;
- next(
  ...__namedParameters: [] | [unknown]
  ): Promise<IteratorResult<T, undefined>>;
- return(
  value?: PromiseLike<undefined>
  ): Promise<IteratorResult<T, undefined>>;
- throw(
  e?: any
  ): Promise<IteratorResult<T, undefined>>;
interface ReadableStreamBYOBReader
- readonly closed: Promise<void>
- cancel(
  reason?: any
  ): Promise<void>;
- read<T extends NonSharedArrayBufferView>(
  view: T,
  options?: ReadableStreamBYOBReaderReadOptions
  ): Promise<ReadableStreamReadResult<T>>;
- releaseLock(): void;
interface ReadableStreamBYOBReaderReadOptions
- min?: number
interface ReadableStreamBYOBRequest
- readonly view: null | NonSharedArrayBufferView
- respond(
  bytesWritten: number
  ): void;
- respondWithNewView(
  view: NonSharedArrayBufferView
  ): void;
interface ReadableStreamDefaultController<R = any>
- readonly desiredSize: null | number
- close(): void;
- enqueue(
  chunk?: R
  ): void;
- error(
  e?: any
  ): void;
interface ReadableStreamDefaultReader<R = any>
- readonly closed: Promise<void>
- cancel(
  reason?: any
  ): Promise<void>;
- read(): Promise<ReadableStreamReadResult<R>>;
- releaseLock(): void;
interface ReadableStreamGenericReader
- readonly closed: Promise<void>
- cancel(
  reason?: any
  ): Promise<void>;
interface ReadableStreamGetReaderOptions
- mode?: 'byob'
interface ReadableStreamIteratorOptions
- preventCancel?: boolean
interface ReadableStreamReadDoneResult<T>
- done: true
- value: undefined | T
interface ReadableStreamReadValueResult<T>
- done: false
- value: T
interface ReadableWritablePair<R = any, W = any>
- readable: ReadableStream<R>
- writable: WritableStream<W>
interface StreamPipeOptions
- preventAbort?: boolean
- preventCancel?: boolean
- preventClose?: boolean
- signal?: AbortSignal
interface TextDecoderStream
- readonly encoding: string
- readonly fatal: boolean
- readonly ignoreBOM: boolean
- readonly readable: ReadableStream<string>
- readonly writable: WritableStream<BufferSource>
interface TextEncoderStream
- readonly encoding: string
- readonly readable: ReadableStream<NonSharedUint8Array>
- readonly writable: WritableStream<string>
interface Transformer<I = any, O = any>
- flush?: TransformerFlushCallback<O>
- readableType?: undefined
- start?: TransformerStartCallback<O>
- transform?: TransformerTransformCallback<I, O>
- writableType?: undefined
interface TransformerFlushCallback<O>
interface TransformerStartCallback<O>
interface TransformerTransformCallback<I, O>
interface TransformStream<I = any, O = any>
- readonly readable: ReadableStream<O>
- readonly writable: WritableStream<I>
interface TransformStreamDefaultController<O = any>
- readonly desiredSize: null | number
- enqueue(
  chunk?: O
  ): void;
- error(
  reason?: any
  ): void;
- terminate(): void;
interface UnderlyingByteSource
- autoAllocateChunkSize?: number
- cancel?: UnderlyingSourceCancelCallback
- pull?: (controller: ReadableByteStreamController) => void | PromiseLike<void>
- start?: (controller: ReadableByteStreamController) => any
- type: 'bytes'
interface UnderlyingDefaultSource<R = any>
- cancel?: UnderlyingSourceCancelCallback
- pull?: (controller: ReadableStreamDefaultController<R>) => void | PromiseLike<void>
- start?: (controller: ReadableStreamDefaultController<R>) => any
- type?: undefined
interface UnderlyingSink<W = any>
- abort?: UnderlyingSinkAbortCallback
- close?: UnderlyingSinkCloseCallback
- start?: UnderlyingSinkStartCallback
- type?: undefined
- write?: UnderlyingSinkWriteCallback<W>
interface UnderlyingSinkAbortCallback
interface UnderlyingSinkCloseCallback
interface UnderlyingSinkStartCallback
interface UnderlyingSinkWriteCallback<W>
interface UnderlyingSource<R = any>
- autoAllocateChunkSize?: number
- cancel?: UnderlyingSourceCancelCallback
- pull?: UnderlyingSourcePullCallback<R>
- start?: UnderlyingSourceStartCallback<R>
- type?: 'bytes'
interface UnderlyingSourceCancelCallback
interface UnderlyingSourcePullCallback<R>
interface UnderlyingSourceStartCallback<R>
interface WritableStream<W = any>
- readonly locked: boolean
- abort(
  reason?: any
  ): Promise<void>;
- close(): Promise<void>;
- getWriter(): WritableStreamDefaultWriter<W>;
interface WritableStreamDefaultController
- readonly signal: AbortSignal
- error(
  e?: any
  ): void;
interface WritableStreamDefaultWriter<W = any>
- readonly closed: Promise<void>
- readonly desiredSize: null | number
- readonly ready: Promise<void>
- abort(
  reason?: any
  ): Promise<void>;
- close(): Promise<void>;
- releaseLock(): void;
- write(
  chunk?: W
  ): Promise<void>;
type CompressionFormat = 'brotli' | 'deflate' | 'deflate-raw' | 'gzip'
type ReadableStreamController<T> = ReadableStreamDefaultController<T> | ReadableByteStreamController
type ReadableStreamReader<T> = ReadableStreamDefaultReader<T> | ReadableStreamBYOBReader
type ReadableStreamReaderMode = 'byob'
type ReadableStreamReadResult<T> = ReadableStreamReadValueResult<T> | ReadableStreamReadDoneResult<T>
type ReadableStreamType = 'bytes'

stream/web

Type definitions

interface ByteLengthQueuingStrategy

interface CompressionStream

interface CountQueuingStrategy

interface DecompressionStream

interface GenericTransformStream

interface QueuingStrategy<T = any>

interface QueuingStrategyInit

interface QueuingStrategySize<T = any>

interface ReadableByteStreamController

interface ReadableStream<R = any>

interface ReadableStreamAsyncIterator<T>

interface ReadableStreamBYOBReader

interface ReadableStreamBYOBReaderReadOptions

interface ReadableStreamBYOBRequest

interface ReadableStreamDefaultController<R = any>

interface ReadableStreamDefaultReader<R = any>

interface ReadableStreamGenericReader

interface ReadableStreamGetReaderOptions

interface ReadableStreamIteratorOptions

interface ReadableStreamReadDoneResult<T>

interface ReadableStreamReadValueResult<T>

interface ReadableWritablePair<R = any, W = any>

interface StreamPipeOptions

interface TextDecoderStream

interface TextEncoderStream

interface Transformer<I = any, O = any>

interface TransformerFlushCallback<O>

interface TransformerStartCallback<O>

interface TransformerTransformCallback<I, O>

interface TransformStream<I = any, O = any>

interface TransformStreamDefaultController<O = any>

interface UnderlyingByteSource

interface UnderlyingDefaultSource<R = any>

interface UnderlyingSink<W = any>

interface UnderlyingSinkAbortCallback

interface UnderlyingSinkCloseCallback

interface UnderlyingSinkStartCallback

interface UnderlyingSinkWriteCallback<W>

interface UnderlyingSource<R = any>

interface UnderlyingSourceCancelCallback

interface UnderlyingSourcePullCallback<R>

interface UnderlyingSourceStartCallback<R>

interface WritableStream<W = any>

interface WritableStreamDefaultController

interface WritableStreamDefaultWriter<W = any>