internal.Duplex - node__stream.d.ts - Node

class internal.Duplex

extends ReadableBase

Usage in Deno

```typescript import { internal } from "node:node__stream.d.ts"; ```

Duplex streams are streams that implement both the `Readable` and `Writable` interfaces. Examples of `Duplex` streams include: * `TCP sockets` * `zlib streams` * `crypto streams`

Constructors

new



Duplex(opts?: DuplexOptions)

Properties



allowHalfOpen: boolean

If `false` then the stream will automatically end the writable side when the readable side ends. Set initially by the `allowHalfOpen` constructor option, which defaults to `true`. This can be changed manually to change the half-open behavior of an existing `Duplex` stream instance, but must be changed before the `'end'` event is emitted.

readonly



closed: boolean

readonly



errored: Error | null

readonly



writable: boolean

readonly



writableCorked: number

readonly



writableEnded: boolean

readonly



writableFinished: boolean

readonly



writableHighWaterMark: number

readonly



writableLength: number

readonly



writableNeedDrain: boolean

readonly



writableObjectMode: boolean

Methods



_destroy(error: Error | null,
callback: (error?: Error | null) => void,
): void



_final(callback: (error?: Error | null) => void): void



_write(chunk: any,
encoding: BufferEncoding,
callback: (error?: Error | null) => void,
): void

abstract



_writev(chunks: Array<{ chunk: any; encoding: BufferEncoding;  }>,
callback: (error?: Error | null) => void,
): void



addListener(event: "close",
listener: () => void,
): this

Event emitter The defined events on documents including: 1. close 2. data 3. drain 4. end 5. error 6. finish 7. pause 8. pipe 9. readable 10. resume 11. unpipe



addListener(event: "data",
listener: (chunk: any) => void,
): this



addListener(event: "drain",
listener: () => void,
): this



addListener(event: "end",
listener: () => void,
): this



addListener(event: "error",
listener: (err: Error) => void,
): this



addListener(event: "finish",
listener: () => void,
): this



addListener(event: "pause",
listener: () => void,
): this



addListener(event: "pipe",
listener: (src: Readable) => void,
): this



addListener(event: "readable",
listener: () => void,
): this



addListener(event: "resume",
listener: () => void,
): this



addListener(event: "unpipe",
listener: (src: Readable) => void,
): this



addListener(event: string | symbol,
listener: (...args: any[]) => void,
): this



cork(): void



emit(event: "close"): boolean



emit(event: "data",
chunk: any,
): boolean



emit(event: "drain"): boolean



emit(event: "end"): boolean



emit(event: "error",
err: Error,
): boolean



emit(event: "finish"): boolean



emit(event: "pause"): boolean



emit(event: "pipe",
src: Readable,
): boolean



emit(event: "readable"): boolean



emit(event: "resume"): boolean



emit(event: "unpipe",
src: Readable,
): boolean



emit(event: string | symbol,
...args: any[],
): boolean



end(cb?: () => void): this



end(chunk: any,
cb?: () => void,
): this



end(chunk: any,
encoding?: BufferEncoding,
cb?: () => void,
): this



on(event: "close",
listener: () => void,
): this



on(event: "data",
listener: (chunk: any) => void,
): this



on(event: "drain",
listener: () => void,
): this



on(event: "end",
listener: () => void,
): this



on(event: "error",
listener: (err: Error) => void,
): this



on(event: "finish",
listener: () => void,
): this



on(event: "pause",
listener: () => void,
): this



on(event: "pipe",
listener: (src: Readable) => void,
): this



on(event: "readable",
listener: () => void,
): this



on(event: "resume",
listener: () => void,
): this



on(event: "unpipe",
listener: (src: Readable) => void,
): this



on(event: string | symbol,
listener: (...args: any[]) => void,
): this



once(event: "close",
listener: () => void,
): this



once(event: "data",
listener: (chunk: any) => void,
): this



once(event: "drain",
listener: () => void,
): this



once(event: "end",
listener: () => void,
): this



once(event: "error",
listener: (err: Error) => void,
): this



once(event: "finish",
listener: () => void,
): this



once(event: "pause",
listener: () => void,
): this



once(event: "pipe",
listener: (src: Readable) => void,
): this



once(event: "readable",
listener: () => void,
): this



once(event: "resume",
listener: () => void,
): this



once(event: "unpipe",
listener: (src: Readable) => void,
): this



once(event: string | symbol,
listener: (...args: any[]) => void,
): this



prependListener(event: "close",
listener: () => void,
): this



prependListener(event: "data",
listener: (chunk: any) => void,
): this



prependListener(event: "drain",
listener: () => void,
): this



prependListener(event: "end",
listener: () => void,
): this



prependListener(event: "error",
listener: (err: Error) => void,
): this



prependListener(event: "finish",
listener: () => void,
): this



prependListener(event: "pause",
listener: () => void,
): this



prependListener(event: "pipe",
listener: (src: Readable) => void,
): this



prependListener(event: "readable",
listener: () => void,
): this



prependListener(event: "resume",
listener: () => void,
): this



prependListener(event: "unpipe",
listener: (src: Readable) => void,
): this



prependListener(event: string | symbol,
listener: (...args: any[]) => void,
): this



prependOnceListener(event: "close",
listener: () => void,
): this



prependOnceListener(event: "data",
listener: (chunk: any) => void,
): this



prependOnceListener(event: "drain",
listener: () => void,
): this



prependOnceListener(event: "end",
listener: () => void,
): this



prependOnceListener(event: "error",
listener: (err: Error) => void,
): this



prependOnceListener(event: "finish",
listener: () => void,
): this



prependOnceListener(event: "pause",
listener: () => void,
): this



prependOnceListener(event: "pipe",
listener: (src: Readable) => void,
): this



prependOnceListener(event: "readable",
listener: () => void,
): this



prependOnceListener(event: "resume",
listener: () => void,
): this



prependOnceListener(event: "unpipe",
listener: (src: Readable) => void,
): this



prependOnceListener(event: string | symbol,
listener: (...args: any[]) => void,
): this



removeListener(event: "close",
listener: () => void,
): this



removeListener(event: "data",
listener: (chunk: any) => void,
): this



removeListener(event: "drain",
listener: () => void,
): this



removeListener(event: "end",
listener: () => void,
): this



removeListener(event: "error",
listener: (err: Error) => void,
): this



removeListener(event: "finish",
listener: () => void,
): this



removeListener(event: "pause",
listener: () => void,
): this



removeListener(event: "pipe",
listener: (src: Readable) => void,
): this



removeListener(event: "readable",
listener: () => void,
): this



removeListener(event: "resume",
listener: () => void,
): this



removeListener(event: "unpipe",
listener: (src: Readable) => void,
): this



removeListener(event: string | symbol,
listener: (...args: any[]) => void,
): this



setDefaultEncoding(encoding: BufferEncoding): this



uncork(): void



write(chunk: any,
encoding?: BufferEncoding,
cb?: (error: Error
 | null
 | undefined) => void,
): boolean



write(chunk: any,
cb?: (error: Error
 | null
 | undefined) => void,
): boolean

Static Methods



from(src: Stream
 | NodeBlob
 | ArrayBuffer
 | string
 | Iterable<any>
 | AsyncIterable<any>
 | AsyncGeneratorFunction
 | Promise<any>
 | Object): Duplex

A utility method for creating duplex streams. - `Stream` converts writable stream into writable `Duplex` and readable stream to `Duplex`. - `Blob` converts into readable `Duplex`. - `string` converts into readable `Duplex`. - `ArrayBuffer` converts into readable `Duplex`. - `AsyncIterable` converts into a readable `Duplex`. Cannot yield `null`. - `AsyncGeneratorFunction` converts into a readable/writable transform `Duplex`. Must take a source `AsyncIterable` as first parameter. Cannot yield `null`. - `AsyncFunction` converts into a writable `Duplex`. Must return either `null` or `undefined` - `Object ({ writable, readable })` converts `readable` and `writable` into `Stream` and then combines them into `Duplex` where the `Duplex` will write to the `writable` and read from the `readable`. - `Promise` converts into readable `Duplex`. Value `null` is ignored.



fromWeb(duplexStream: { readable: streamWeb.ReadableStream; writable: streamWeb.WritableStream;  },
options?: Pick<DuplexOptions, "allowHalfOpen"
 | "decodeStrings"
 | "encoding"
 | "highWaterMark"
 | "objectMode"
 | "signal"
>,
): Duplex

A utility method for creating a `Duplex` from a web `ReadableStream` and `WritableStream`.



toWeb(streamDuplex: Duplex): { readable: streamWeb.ReadableStream; writable: streamWeb.WritableStream;  }

A utility method for creating a web `ReadableStream` and `WritableStream` from a `Duplex`.