Node.js module

node:stream/iter

namespace Broadcast
- function from(
  input: ByteReadableStream | SyncByteReadableStream | Broadcastable,
  options?: BroadcastOptions
  ): BroadcastResult;
  Create a Broadcast from an existing source. The source is consumed automatically and pushed to all subscribers.
  @param options
  Same as broadcast().
namespace Share
- function from(
  input: ByteReadableStream | SyncByteReadableStream | Shareable,
  options?: ShareOptions
  ): Share;
  Create a Share from an existing source.
  @param options
  Same as share().
namespace Stream
namespace SyncShare
- function from(
  input: SyncByteReadableStream | SyncShareable,
  options?: ShareSyncOptions
  ): SyncShare;
const broadcastProtocol: unique symbol
const drainableProtocol: unique symbol
const shareProtocol: unique symbol
const shareSyncProtocol: unique symbol
const toAsyncStreamable: unique symbol
const toStreamable: unique symbol
function array(
source: Source,
options?: ConsumeOptions
): Promise<Uint8Array<ArrayBufferLike>[]>;
function arrayBuffer(
source: Source,
options?: ConsumeOptions
): Promise<ArrayBuffer>;
function arrayBufferSync(
source: SyncSource,
options?: ConsumeSyncOptions
): ArrayBuffer;
function arraySync(
source: SyncSource,
options?: ConsumeSyncOptions
): Uint8Array<ArrayBufferLike>[];
function broadcast(
options?: BroadcastOptions
): BroadcastResult;
function bytes(
source: Source,
options?: ConsumeOptions
): Promise<Uint8Array<ArrayBufferLike>>;
function bytesSync(
source: SyncSource,
options?: ConsumeSyncOptions
): Uint8Array;
function duplex(
options?: DuplexOptions
): [DuplexChannel, DuplexChannel];
function from(
input: Source
): ByteReadableStream;
function fromSync(
input: SyncSource
): SyncByteReadableStream;
function merge(
...sources: Source[]
): ByteReadableStream;
function merge(
...args: [...sources: Source[], options: MergeOptions]
): ByteReadableStream;
function ondrain(
drainable: any
): null | Promise<boolean>;
function pipeTo(
source: Source,
writer: PartialWriter,
options?: PipeToOptions
): Promise<number>;
function pipeTo(
source: Source,
...args: [...transforms: Transform[], writer: PartialWriter]
): Promise<number>;
function pipeTo(
source: Source,
...args: [...transforms: Transform[], writer: PartialWriter, options: PipeToOptions]
): Promise<number>;
function pipeToSync(
source: SyncSource,
writer: PartialSyncWriter,
options?: PipeToSyncOptions
): number;
function pipeToSync(
source: SyncSource,
...args: [...transforms: SyncTransform[], writer: PartialSyncWriter]
): number;
function pipeToSync(
source: SyncSource,
...args: [...transforms: SyncTransform[], writer: PartialSyncWriter, options: PipeToSyncOptions]
): number;
function pull(
source: Source,
...transforms: Transform[]
): ByteReadableStream;
function pull(
source: Source,
...args: [...transforms: Transform[], options: PullOptions]
): ByteReadableStream;
function pullSync(
source: SyncSource,
...transforms: SyncTransform[]
): SyncByteReadableStream;
function push(
...transforms: Transform[]
): PushStreamResult;
function push(
...args: [...transforms: Transform[], options: PushStreamOptions]
): PushStreamResult;
function share(
source: Source,
options?: ShareOptions
): Share;
function shareSync(
source: SyncSource,
options?: ShareSyncOptions
): SyncShare;
function tap(
callback: StatelessTransformFn
): StatelessTransformFn;
function tapSync(
callback: SyncStatelessTransformFn
): SyncStatelessTransformFn;
function text(
source: Source,
options?: TextConsumeOptions
): Promise<string>;
function textSync(
source: SyncSource,
options?: TextConsumeSyncOptions
): string;

Type definitions

interface AsyncStreamable
- [toAsyncStreamable](): Source;
interface Broadcast
- readonly bufferSize: number
- readonly consumerCount: number
- [Symbol.dispose](): void;
- cancel(
  reason?: any
  ): void;
- push(
  ...args: any[]
  ): ByteReadableStream;
interface Broadcastable
- [broadcastProtocol](
  options: BroadcastOptions
  ): Broadcast;
interface BroadcastOptions
- backpressure?: BackpressurePolicy
- highWaterMark?: number
- signal?: AbortSignal
interface BroadcastResult
- broadcast: Broadcast
- writer: BroadcastWriter
interface BroadcastWriter
- readonly desiredSize: null | number
- [Symbol.asyncDispose](): PromiseLike<void>;
- [Symbol.dispose](): void;
- [drainableProtocol](): null | Promise<boolean>;
- end(
  options?: WriteOptions
  ): Promise<number>;
- endSync(): number;
- fail(
  reason?: any
  ): void;
- write(
  chunk: string | Uint8Array<ArrayBufferLike>,
  options?: WriteOptions
  ): Promise<void>;
- writeSync(
  chunk: string | Uint8Array<ArrayBufferLike>
  ): boolean;
- writev(
  chunks: string | Uint8Array<ArrayBufferLike>[],
  options?: WriteOptions
  ): Promise<void>;
- writevSync(
  chunks: string | Uint8Array<ArrayBufferLike>[]
  ): boolean;
interface ConsumeOptions
- limit?: number
- signal?: AbortSignal
interface ConsumeSyncOptions
- limit?: number
interface Drainable
- [drainableProtocol](): null | Promise<boolean>;
interface DuplexChannel
- readonly readable: ByteReadableStream
- readonly writer: Writer
- [Symbol.asyncDispose](): PromiseLike<void>;
- close(): Promise<void>;
interface DuplexDirectionOptions
- backpressure?: BackpressurePolicy
- highWaterMark?: number
interface DuplexOptions
- a?: DuplexDirectionOptions
- b?: DuplexDirectionOptions
- backpressure?: BackpressurePolicy
- highWaterMark?: number
- signal?: AbortSignal
interface MergeOptions
- signal?: AbortSignal
interface PartialSyncWriter
- [Symbol.dispose]?: () => void
- readonly desiredSize?: null | number
- endSync?: () => number
- fail?: (reason?: any) => void
- writevSync?: (chunks: string | Uint8Array<ArrayBufferLike>[]) => number
- writeSync(
  chunk: string | Uint8Array<ArrayBufferLike>
  ): number;
interface PartialWriter
- [Symbol.asyncDispose]?: () => PromiseLike<void>
- [Symbol.dispose]?: () => void
- readonly desiredSize?: null | number
- end?: (options?: WriteOptions) => Promise<number>
- endSync?: () => number
- fail?: (reason?: any) => void
- writeSync?: (chunk: string | Uint8Array<ArrayBufferLike>) => boolean
- writev?: (chunks: string | Uint8Array<ArrayBufferLike>[], options?: WriteOptions) => Promise<void>
- writevSync?: (chunks: string | Uint8Array<ArrayBufferLike>[]) => boolean
- write(
  chunk: string | Uint8Array<ArrayBufferLike>,
  options?: WriteOptions
  ): Promise<void>;
interface PipeToOptions
- preventClose?: boolean
- preventFail?: boolean
- signal?: AbortSignal
interface PipeToSyncOptions
- preventClose?: boolean
- preventFail?: boolean
interface PullOptions
- signal?: AbortSignal
interface PushStreamOptions
- backpressure?: BackpressurePolicy
- highWaterMark?: number
- signal?: AbortSignal
interface PushStreamResult
- readable: ByteReadableStream
- writer: PushWriter
interface PushWriter
- readonly desiredSize: null | number
- [Symbol.asyncDispose](): PromiseLike<void>;
- [Symbol.dispose](): void;
- [drainableProtocol](): null | Promise<boolean>;
- end(
  options?: WriteOptions
  ): Promise<number>;
- endSync(): number;
- fail(
  reason?: any
  ): void;
- write(
  chunk: string | Uint8Array<ArrayBufferLike>,
  options?: WriteOptions
  ): Promise<void>;
- writeSync(
  chunk: string | Uint8Array<ArrayBufferLike>
  ): boolean;
- writev(
  chunks: string | Uint8Array<ArrayBufferLike>[],
  options?: WriteOptions
  ): Promise<void>;
- writevSync(
  chunks: string | Uint8Array<ArrayBufferLike>[]
  ): boolean;
interface Share
- readonly bufferSize: number
- readonly consumerCount: number
- [Symbol.dispose](): void;
- cancel(
  reason?: any
  ): void;
- pull(
  ...args: any[]
  ): ByteReadableStream;
interface Shareable
- [shareProtocol](
  options: ShareOptions
  ): Share;
interface ShareOptions
- backpressure?: BackpressurePolicy
- highWaterMark?: number
- signal?: AbortSignal
interface ShareSyncOptions
- backpressure?: BackpressurePolicy
- highWaterMark?: number
interface StatefulTransform
- transform(
  source: AsyncIterable<null | Uint8Array<ArrayBufferLike>[]>,
  options: TransformCallbackOptions
  ): AsyncIterable<TransformResult>;
interface StatelessTransformFn
interface Streamable
- [toStreamable](): SyncSource;
interface SyncShare
- readonly bufferSize: number
- readonly consumerCount: number
- [Symbol.dispose](): void;
- cancel(
  reason?: any
  ): void;
- pull(
  ...args: any
  ): SyncByteReadableStream;
interface SyncShareable
- [shareSyncProtocol](
  options: ShareSyncOptions
  ): SyncShare;
interface SyncStatefulTransform
- transform(
  source: Iterable<null | Uint8Array<ArrayBufferLike>[]>
  ): Iterable<SyncTransformResult>;
interface SyncStatelessTransformFn
interface SyncWriter
- readonly desiredSize: null | number
- [Symbol.dispose](): void;
- endSync(): number;
- fail(
  reason?: any
  ): void;
- writeSync(
  chunk: string | Uint8Array<ArrayBufferLike>
  ): number;
- writevSync(
  chunks: string | Uint8Array<ArrayBufferLike>[]
  ): number;
interface TextConsumeOptions
- encoding?: string
- limit?: number
- signal?: AbortSignal
interface TextConsumeSyncOptions
- encoding?: string
- limit?: number
interface TransformCallbackOptions
- signal: AbortSignal
interface WriteOptions
- signal?: AbortSignal
interface Writer
- readonly desiredSize: null | number
- [Symbol.asyncDispose](): PromiseLike<void>;
- [Symbol.dispose](): void;
- end(
  options?: WriteOptions
  ): Promise<number>;
- endSync(): number;
- fail(
  reason?: any
  ): void;
- write(
  chunk: string | Uint8Array<ArrayBufferLike>,
  options?: WriteOptions
  ): Promise<void>;
- writeSync(
  chunk: string | Uint8Array<ArrayBufferLike>
  ): boolean;
- writev(
  chunks: string | Uint8Array<ArrayBufferLike>[],
  options?: WriteOptions
  ): Promise<void>;
- writevSync(
  chunks: string | Uint8Array<ArrayBufferLike>[]
  ): boolean;
type BackpressurePolicy = 'strict' | 'block' | 'drop-oldest' | 'drop-newest'
type ByteReadableStream = AsyncIterable<Uint8Array[]>
type Source = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncSource> | AsyncIterable<Source> | Streamable | AsyncStreamable
type SyncByteReadableStream = Iterable<Uint8Array[]>
type SyncSource = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncSource> | Streamable
type SyncTransform = SyncStatelessTransformFn | SyncStatefulTransform
type SyncTransformResult = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncTransformResult>
type Transform = StatelessTransformFn | StatefulTransform
type TransformResult = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncTransformResult> | AsyncIterable<TransformResult>

node:stream/iter

namespace Broadcast

namespace Share

namespace Stream

namespace SyncShare

Type definitions

interface AsyncStreamable

interface Broadcast

interface Broadcastable

interface BroadcastOptions

interface BroadcastResult

interface BroadcastWriter

interface ConsumeOptions

interface ConsumeSyncOptions

interface Drainable

interface DuplexChannel

interface DuplexDirectionOptions

interface DuplexOptions

interface MergeOptions

interface PartialSyncWriter

interface PartialWriter

interface PipeToOptions

interface PipeToSyncOptions

interface PullOptions

interface PushStreamOptions

interface PushStreamResult

interface PushWriter

interface Share

interface Shareable

interface ShareOptions

interface ShareSyncOptions

interface StatefulTransform

interface StatelessTransformFn

interface Streamable

interface SyncShare

interface SyncShareable

interface SyncStatefulTransform

interface SyncStatelessTransformFn

interface SyncWriter

interface TextConsumeOptions

interface TextConsumeSyncOptions

interface TransformCallbackOptions

interface WriteOptions

interface Writer