The stream.PassThrough class is a trivial implementation of a Transform stream that simply passes the input bytes across to the output. Its purpose is primarily for examples and testing, but there are some use cases where stream.PassThrough is useful as a building block for novel sorts of streams.

Pipe

sealed external interface Pipe

PipelineCallback

typealias PipelineCallback<S> = Any

PipelineDestination

typealias PipelineDestination<S, P> = Any

PipelineDestinationIterableFunction

typealias PipelineDestinationIterableFunction<T> = (source: AsyncIterable<T>) -> AsyncIterable<Any?>

PipelineDestinationPromiseFunction

typealias PipelineDestinationPromiseFunction<T, P> = (source: AsyncIterable<T>) -> Promise

PipelineOptions

sealed external interface PipelineOptions

PipelinePromise

typealias PipelinePromise<S> = Promise<*>

PipelineSource

typealias PipelineSource<T> = Any

PipelineSourceFunction

typealias PipelineSourceFunction<T> = () -> Any

PipelineTransform

typealias PipelineTransform<S, U> = Any

PipelineTransformSource

typealias PipelineTransformSource<T> = Any

Readable

open external class Readable : Stream, ReadableStream

ReadableBaseIteratorOptions

sealed external interface ReadableBaseIteratorOptions

ReadableEvent

sealed external interface ReadableEvent

ReadableOptions

sealed external interface ReadableOptions : StreamOptions<Stream>

Stream

open external class Stream : EventEmitter

StreamComposeOptions

sealed external interface StreamComposeOptions

StreamOptions

sealed external interface StreamOptions<T : Stream> : Abortable

StreamPipeOptions

sealed external interface StreamPipeOptions

Transform

open external class Transform : Duplex

Transform streams are Duplex streams where the output is in some way related to the input. Like all Duplex streams, Transform streams implement both the Readable and Writable interfaces.

TransformCallback

typealias TransformCallback = (error: JsError?, data: Any?) -> Unit

TransformOptions

external interface TransformOptions : DuplexOptions

Writable

open external class Writable : Stream, WritableStream

WritableEvent

sealed external interface WritableEvent

WritableOptions

sealed external interface WritableOptions : StreamOptions<Stream>

WritableOptionsWritevChunksItem

sealed external interface WritableOptionsWritevChunksItem

WritableWritevChunksItem

sealed external interface WritableWritevChunksItem

Properties

consumers

external val consumers: Any

promises

external val promises: Any

Functions

addAbortSignal

external fun <T : Stream> addAbortSignal(signal: AbortSignal, stream: T): T

A stream to attach a signal to.

finished

external fun finished(stream: ReadWriteStream, callback: (err: ErrnoException?) -> Unit): () -> Unit

suspend fun finished(stream: ReadWriteStream, options: FinishedOptions = undefined.unsafeCast<Nothing>()): Void

external fun finished(stream: ReadableStream, callback: (err: ErrnoException?) -> Unit): () -> Unit

suspend fun finished(stream: ReadableStream, options: FinishedOptions = undefined.unsafeCast<Nothing>()): Void

external fun finished(stream: WritableStream, callback: (err: ErrnoException?) -> Unit): () -> Unit

suspend fun finished(stream: WritableStream, options: FinishedOptions = undefined.unsafeCast<Nothing>()): Void

external fun finished(stream: ReadWriteStream, options: FinishedOptions, callback: (err: ErrnoException?) -> Unit): () -> Unit

external fun finished(stream: ReadableStream, options: FinishedOptions, callback: (err: ErrnoException?) -> Unit): () -> Unit

external fun finished(stream: WritableStream, options: FinishedOptions, callback: (err: ErrnoException?) -> Unit): () -> Unit

A readable and/or writable stream/webstream.

finishedAsync

external fun finishedAsync(stream: ReadWriteStream, options: FinishedOptions = definedExternally): Promise<Void>

external fun finishedAsync(stream: ReadableStream, options: FinishedOptions = definedExternally): Promise<Void>

external fun finishedAsync(stream: WritableStream, options: FinishedOptions = definedExternally): Promise<Void>

getDefaultHighWaterMark

external fun getDefaultHighWaterMark(objectMode: Boolean): Double

Returns the default highWaterMark used by streams. Defaults to 65536 (64 KiB), or 16 for objectMode.

isErrored

external fun isErrored(stream: ReadableStream): Boolean

external fun isErrored(stream: WritableStream): Boolean

external fun isErrored(stream: Readable): Boolean

external fun isErrored(stream: Writable): Boolean

Returns whether the stream has encountered an error.

isReadable

external fun isReadable(stream: ReadableStream): Boolean

external fun isReadable(stream: Readable): Boolean

Returns whether the stream is readable.

pipeline

external fun pipeline(streams: ReadonlyArray<Any>, callback: (err: ErrnoException?) -> Unit): WritableStream

suspend fun pipeline(streams: ReadonlyArray<Any>, options: PipelineOptions = undefined.unsafeCast<Nothing>()): Void

suspend fun <A : PipelineSource<Any?>, B : PipelineDestination<A, Any?>> pipeline(source: A, destination: B, options: PipelineOptions = undefined.unsafeCast<Nothing>()): Any?

suspend fun pipeline(stream1: ReadableStream, stream2: ReadWriteStream, vararg streams: Any): Void

suspend fun pipeline(stream1: ReadableStream, stream2: WritableStream, vararg streams: Any): Void

external fun <A : PipelineSource<Any?>, T1 : PipelineTransform<A, Any?>, B : PipelineDestination<T1, Any?>> pipeline(source: A, transform1: T1, destination: B, callback: PipelineCallback): Any

suspend fun <A : PipelineSource<Any?>, T1 : PipelineTransform<A, Any?>, B : PipelineDestination<T1, Any?>> pipeline(source: A, transform1: T1, destination: B, options: PipelineOptions = undefined.unsafeCast<Nothing>()): Any?

external fun <A : PipelineSource<Any?>, T1 : PipelineTransform<A, Any?>, T2 : PipelineTransform<T1, Any?>, B : PipelineDestination<T2, Any?>> pipeline(source: A, transform1: T1, transform2: T2, destination: B, callback: PipelineCallback): Any

suspend fun <A : PipelineSource<Any?>, T1 : PipelineTransform<A, Any?>, T2 : PipelineTransform<T1, Any?>, B : PipelineDestination<T2, Any?>> pipeline(source: A, transform1: T1, transform2: T2, destination: B, options: PipelineOptions = undefined.unsafeCast<Nothing>()): Any?

external fun <A : PipelineSource<Any?>, T1 : PipelineTransform<A, Any?>, T2 : PipelineTransform<T1, Any?>, T3 : PipelineTransform<T2, Any?>, B : PipelineDestination<T3, Any?>> pipeline(source: A, transform1: T1, transform2: T2, transform3: T3, destination: B, callback: PipelineCallback): Any

suspend fun <A : PipelineSource<Any?>, T1 : PipelineTransform<A, Any?>, T2 : PipelineTransform<T1, Any?>, T3 : PipelineTransform<T2, Any?>, B : PipelineDestination<T3, Any?>> pipeline(source: A, transform1: T1, transform2: T2, transform3: T3, destination: B, options: PipelineOptions = undefined.unsafeCast<Nothing>()): Any?

external fun <A : PipelineSource<Any?>, T1 : PipelineTransform<A, Any?>, T2 : PipelineTransform<T1, Any?>, T3 : PipelineTransform<T2, Any?>, T4 : PipelineTransform<T3, Any?>, B : PipelineDestination<T4, Any?>> pipeline(source: A, transform1: T1, transform2: T2, transform3: T3, transform4: T4, destination: B, callback: PipelineCallback): Any

suspend fun <A : PipelineSource<Any?>, T1 : PipelineTransform<A, Any?>, T2 : PipelineTransform<T1, Any?>, T3 : PipelineTransform<T2, Any?>, T4 : PipelineTransform<T3, Any?>, B : PipelineDestination<T4, Any?>> pipeline(source: A, transform1: T1, transform2: T2, transform3: T3, transform4: T4, destination: B, options: PipelineOptions = undefined.unsafeCast<Nothing>()): Any?

external fun <A : PipelineSource<Any?>, B : PipelineDestination<A, Any?>> pipeline(source: A, destination: B, callback: PipelineCallback): Any

A module method to pipe between streams and generators forwarding errors and properly cleaning up and provide a callback when the pipeline is complete.

pipelineAsync

external fun pipelineAsync(streams: ReadonlyArray<Any>, options: PipelineOptions = definedExternally): Promise<Void>

external fun <A : PipelineSource<Any?>, B : PipelineDestination<A, Any?>> pipelineAsync(source: A, destination: B, options: PipelineOptions = definedExternally): PipelinePromise

external fun pipelineAsync(stream1: ReadableStream, stream2: ReadWriteStream, vararg streams: Any): Promise<Void>

external fun pipelineAsync(stream1: ReadableStream, stream2: WritableStream, vararg streams: Any): Promise<Void>

external fun <A : PipelineSource<Any?>, T1 : PipelineTransform<A, Any?>, B : PipelineDestination<T1, Any?>> pipelineAsync(source: A, transform1: T1, destination: B, options: PipelineOptions = definedExternally): PipelinePromise

external fun <A : PipelineSource<Any?>, T1 : PipelineTransform<A, Any?>, T2 : PipelineTransform<T1, Any?>, B : PipelineDestination<T2, Any?>> pipelineAsync(source: A, transform1: T1, transform2: T2, destination: B, options: PipelineOptions = definedExternally): PipelinePromise

external fun <A : PipelineSource<Any?>, T1 : PipelineTransform<A, Any?>, T2 : PipelineTransform<T1, Any?>, T3 : PipelineTransform<T2, Any?>, B : PipelineDestination<T3, Any?>> pipelineAsync(source: A, transform1: T1, transform2: T2, transform3: T3, destination: B, options: PipelineOptions = definedExternally): PipelinePromise

external fun <A : PipelineSource<Any?>, T1 : PipelineTransform<A, Any?>, T2 : PipelineTransform<T1, Any?>, T3 : PipelineTransform<T2, Any?>, T4 : PipelineTransform<T3, Any?>, B : PipelineDestination<T4, Any?>> pipelineAsync(source: A, transform1: T1, transform2: T2, transform3: T3, transform4: T4, destination: B, options: PipelineOptions = definedExternally): PipelinePromise

setDefaultHighWaterMark

external fun setDefaultHighWaterMark(objectMode: Boolean, value: Number)

Sets the default highWaterMark used by streams.