Is true after writable.end() has been called. This property does not indicate whether the data has been flushed, for this use writable.writableFinished instead.

writableFinished

open val writableFinished: Boolean

Is set to true immediately before the 'finish' event is emitted.

writableHighWaterMark

open val writableHighWaterMark: Double

Return the value of highWaterMark passed when creating this Writable.

writableLength

open val writableLength: Double

This property contains the number of bytes (or objects) in the queue ready to be written. The value provides introspection data regarding the status of the highWaterMark.

writableNeedDrain

open val writableNeedDrain: Boolean

Is true if the stream's buffer has been full and stream will emit 'drain'.

writableObjectMode

open val writableObjectMode: Boolean

Getter for the property objectMode of a given Writable stream.

Functions

_destroy

open fun _destroy(error: JsError?, callback: (JsError?) -> Unit)

_final

open fun _final(callback: (JsError?) -> Unit)

_write

open fun _write(chunk: Any?, encoding: BufferEncoding, callback: (JsError?) -> Unit)

addListener

open fun addListener(event: Symbol, listener: Function<Unit>)

open fun addListener(event: String, listener: Function<Unit>)

fun addListener(event: WritableEvent.DRAIN, listener: () -> Unit)

fun addListener(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun addListener(event: WritableEvent.FINISH, listener: () -> Unit)

fun addListener(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun addListener(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

fun addListener(event: WritableEvent.CLOSE, listener: () -> Unit)

Event emitter The defined events on documents including:

compose

open fun <T : ReadableStream> compose(stream: T, options: StreamComposeOptions = definedExternally): T

open fun <T : ReadableStream> compose(stream: AsyncIterable<T>, options: StreamComposeOptions = definedExternally): T

open fun <T : ReadableStream> compose(stream: JsIterable<T>, options: StreamComposeOptions = definedExternally): T

open fun <T : ReadableStream> compose(stream: ComposeFnParam, options: StreamComposeOptions = definedExternally): T

cork

open fun cork()

The writable.cork() method forces all written data to be buffered in memory. The buffered data will be flushed when either the {@link uncork} or {@link end} methods are called.

destroy

open fun destroy()

Destroy the stream. Optionally emit an 'error' event, and emit a 'close' event (unless emitClose is set to false). After this call, the writable stream has ended and subsequent calls to write() or end() will result in an ERR_STREAM_DESTROYED error. This is a destructive and immediate way to destroy a stream. Previous calls to write() may not have drained, and may trigger an ERR_STREAM_DESTROYED error. Use end() instead of destroy if data should flush before close, or wait for the 'drain' event before destroying the stream.

open fun destroy(error: JsError)

emit

fun emit(event: WritableEvent.CLOSE): Boolean

fun emit(event: WritableEvent.DRAIN): Boolean

fun emit(event: WritableEvent.FINISH): Boolean

open fun emit(event: Symbol, vararg args: Any?): Boolean

open fun emit(event: String, vararg args: Any?): Boolean

fun emit(event: WritableEvent.ERROR, err: JsError): Boolean

fun emit(event: WritableEvent.PIPE, src: Readable): Boolean

fun emit(event: WritableEvent.UNPIPE, src: Readable): Boolean

end

open override fun end(cb: () -> Unit)

Calling the writable.end() method signals that no more data will be written to the Writable. The optional chunk and encoding arguments allow one final additional chunk of data to be written immediately before closing the stream.

open override fun end(data: Uint8Array, cb: () -> Unit)

open fun end(chunk: Any?, cb: () -> Unit = definedExternally)

open override fun end(data: String, cb: () -> Unit)

open fun end(chunk: Any?, encoding: BufferEncoding, cb: () -> Unit = definedExternally)

open override fun end(str: String, encoding: BufferEncoding, cb: () -> Unit)

eventNames

fun eventNames(): Array<Any>

Returns an array listing the events for which the emitter has registered listeners. The values in the array are strings or Symbols.

getMaxListeners

fun getMaxListeners(): Double

Returns the current max listener value for the EventEmitter which is either set by emitter.setMaxListeners(n) or defaults to {@link defaultMaxListeners}.

open fun on(event: Symbol, listener: Function<Unit>)

open fun on(event: String, listener: Function<Unit>)

fun on(event: WritableEvent.CLOSE, listener: () -> Unit)

fun on(event: WritableEvent.DRAIN, listener: () -> Unit)

fun on(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun on(event: WritableEvent.FINISH, listener: () -> Unit)

fun on(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun on(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

once

open fun once(event: Symbol, listener: Function<Unit>)

open fun once(event: String, listener: Function<Unit>)

fun once(event: WritableEvent.CLOSE, listener: () -> Unit)

fun once(event: WritableEvent.DRAIN, listener: () -> Unit)

fun once(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun once(event: WritableEvent.FINISH, listener: () -> Unit)

fun once(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun once(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

pipe

fun <T : WritableStream> pipe(destination: T, options: StreamPipeOptions = definedExternally): T

prependListener

open fun prependListener(event: Symbol, listener: Function<Unit>)

open fun prependListener(event: String, listener: Function<Unit>)

fun prependListener(event: WritableEvent.CLOSE, listener: () -> Unit)

fun prependListener(event: WritableEvent.DRAIN, listener: () -> Unit)

fun prependListener(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun prependListener(event: WritableEvent.FINISH, listener: () -> Unit)

fun prependListener(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun prependListener(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

prependOnceListener

open fun prependOnceListener(event: Symbol, listener: Function<Unit>)

open fun prependOnceListener(event: String, listener: Function<Unit>)

fun prependOnceListener(event: WritableEvent.CLOSE, listener: () -> Unit)

fun prependOnceListener(event: WritableEvent.DRAIN, listener: () -> Unit)

fun prependOnceListener(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun prependOnceListener(event: WritableEvent.FINISH, listener: () -> Unit)

fun prependOnceListener(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun prependOnceListener(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

removeListener

open fun removeListener(event: Symbol, listener: Function<Unit>)

open fun removeListener(event: String, listener: Function<Unit>)

fun removeListener(event: WritableEvent.CLOSE, listener: () -> Unit)

fun removeListener(event: WritableEvent.DRAIN, listener: () -> Unit)

fun removeListener(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun removeListener(event: WritableEvent.FINISH, listener: () -> Unit)

fun removeListener(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun removeListener(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

setDefaultEncoding

open fun setDefaultEncoding(encoding: BufferEncoding)

The writable.setDefaultEncoding() method sets the default encoding for a Writable stream.

setMaxListeners

fun setMaxListeners(n: Number)

By default EventEmitters will print a warning if more than 10 listeners are added for a particular event. This is a useful default that helps finding memory leaks. The emitter.setMaxListeners() method allows the limit to be modified for this specific EventEmitter instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.

uncork

open fun uncork()

The writable.uncork() method flushes all data buffered since {@link cork} was called.

write

open override fun write(buffer: Uint8Array, cb: (JsError?) -> Unit): Boolean

open override fun write(buffer: String, cb: (JsError?) -> Unit): Boolean

open fun write(chunk: Any?, encoding: BufferEncoding, callback: (JsError?) -> Unit = definedExternally): Boolean

open override fun write(str: String, encoding: BufferEncoding, cb: (JsError?) -> Unit): Boolean

open fun write(chunk: Any?, callback: (JsError?) -> Unit = definedExternally): Boolean

The writable.write() method writes some data to the stream, and calls the supplied callback once the data has been fully handled. If an error occurs, the callback will be called with the error as its first argument. The callback is called asynchronously and before 'error' is emitted.