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> = (<Error class: unknown class><T>) -> <Error class: unknown class><Any?>

PipelineDestinationPromiseFunction

typealias PipelineDestinationPromiseFunction<T, P> = (<Error class: unknown class><T>) -> <Error class: unknown class>

PipelineOptions

sealed external interface PipelineOptions

PipelinePromise

typealias PipelinePromise<S> = <Error class: unknown class><out <Error class: unknown class>>

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

ReadableIteratorOptions

sealed external interface ReadableIteratorOptions

ReadableOptions

sealed external interface ReadableOptions<T : Readable> : StreamOptions<T>

ReadableToWebOptions

sealed external interface ReadableToWebOptions

Stream

open external class Stream : EventEmitter

StreamComposeOptions

sealed external interface StreamComposeOptions

StreamOptions

sealed external interface StreamOptions<T : Stream>

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 class: unknown class>?, data: Any?) -> Unit

TransformOptions

external interface TransformOptions<T : Transform> : DuplexOptions<T>

Writable

open external class Writable : Stream, WritableStream

WritableOptions

sealed external interface WritableOptions<T : Writable> : StreamOptions<T>

WritableOptionsWritevChunksItem

sealed external interface WritableOptionsWritevChunksItem

WritableWritevChunksItem

sealed external interface WritableWritevChunksItem

Functions

addAbortSignal

external fun <T : Stream> addAbortSignal(signal: <Error class: unknown class>, stream: T): T

A stream to attach a signal to.

duplexPair

external fun duplexPair(options: DuplexOptions<*> = definedExternally): <Error class: unknown class><Duplex, Duplex>

The utility function duplexPair returns an Array with two items, each being a Duplex stream connected to the other side:

finished

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

suspend external fun finished(stream: ReadWriteStream, options: FinishedOptions = definedExternally): <Error class: unknown class>

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

suspend external fun finished(stream: ReadableStream, options: FinishedOptions = definedExternally): <Error class: unknown class>

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

suspend external fun finished(stream: WritableStream, options: FinishedOptions = definedExternally): <Error class: unknown class>

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): <Error class: unknown class><<Error class: unknown class>>

external fun finishedAsync( stream: ReadableStream, options: FinishedOptions = definedExternally): <Error class: unknown class><<Error class: unknown class>>

external fun finishedAsync( stream: WritableStream, options: FinishedOptions = definedExternally): <Error class: unknown class><<Error class: unknown class>>

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: <Error class: unknown class><Any>, callback: (err: ErrnoException?) -> Unit): WritableStream

suspend external fun pipeline( streams: <Error class: unknown class><Any>, options: PipelineOptions = definedExternally): <Error class: unknown class>

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

suspend external fun pipeline(stream1: ReadableStream, stream2: ReadWriteStream, vararg streams: Any): <Error class: unknown class>

suspend external fun pipeline(stream1: ReadableStream, stream2: WritableStream, vararg streams: Any): <Error class: unknown class>

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

suspend external fun <A : PipelineSource<Any?>, T1 : PipelineTransform<A, Any?>, B : PipelineDestination<T1, Any?>> pipeline( source: A, transform1: T1, destination: B, options: PipelineOptions = definedExternally): 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 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, options: PipelineOptions = definedExternally): 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 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, options: PipelineOptions = definedExternally): 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 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, options: PipelineOptions = definedExternally): 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: <Error class: unknown class><Any>, options: PipelineOptions = definedExternally): <Error class: unknown class><<Error class: unknown class>>

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

external fun pipelineAsync( stream1: ReadableStream, stream2: ReadWriteStream, vararg streams: Any): <Error class: unknown class><<Error class: unknown class>>

external fun pipelineAsync( stream1: ReadableStream, stream2: WritableStream, vararg streams: Any): <Error class: unknown class><<Error class: unknown class>>

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

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): <Error class: unknown class><out <Error class: unknown class>>

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): <Error class: unknown class><out <Error class: unknown class>>

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): <Error class: unknown class><out <Error class: unknown class>>

setDefaultHighWaterMark

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

Sets the default highWaterMark used by streams.