Generic TypeScript declarations for Node.js streams

genericStreams.ts

/**
 * Generic typings for Node.js streams
 */
import stream = require('stream')

export interface EventEmitter {
  addListener(event: string, listener: (...args: any[]) => void): this
  emit(event: string | symbol, ...args: any[]): boolean
  on(event: string, listener: (...args: any[]) => void): this
  once(event: string, listener: (...args: any[]) => void): this
  prependListener(event: string, listener: (...args: any[]) => void): this
  prependOnceListener(event: string, listener: (...args: any[]) => void): this
  removeListener(event: string, listener: (...args: any[]) => void): this
}

// No sane way to incorporate these typings in the current version of TS (2.5.2)

// interface ReadableEventEmitter extends EventEmitter{
//     /**
//      * Event emitter
//      * The defined events on documents including:
//      * 1. close
//      * 2. data
//      * 3. end
//      * 4. readable
//      * 5. error
//      */
//     addListener(event: "close", listener: () => void): this
//     addListener(event: "data", listener: (chunk: Buffer | string) => void): this
//     addListener(event: "end", listener: () => void): this
//     addListener(event: "readable", listener: () => void): this
//     addListener(event: "error", listener: (err: Error) => void): this

//     emit(event: "close"): boolean
//     emit(event: "data", chunk: Buffer | string): boolean
//     emit(event: "end"): boolean
//     emit(event: "readable"): boolean
//     emit(event: "error", err: Error): boolean

//     on(event: "close", listener: () => void): this
//     on(event: "data", listener: (chunk: Buffer | string) => void): this
//     on(event: "end", listener: () => void): this
//     on(event: "readable", listener: () => void): this
//     on(event: "error", listener: (err: Error) => void): this

//     once(event: "close", listener: () => void): this
//     once(event: "data", listener: (chunk: Buffer | string) => void): this
//     once(event: "end", listener: () => void): this
//     once(event: "readable", listener: () => void): this
//     once(event: "error", listener: (err: Error) => void): this

//     prependListener(event: "close", listener: () => void): this
//     prependListener(event: "data", listener: (chunk: Buffer | string) => void): this
//     prependListener(event: "end", listener: () => void): this
//     prependListener(event: "readable", listener: () => void): this
//     prependListener(event: "error", listener: (err: Error) => void): this

//     prependOnceListener(event: "close", listener: () => void): this
//     prependOnceListener(event: "data", listener: (chunk: Buffer | string) => void): this
//     prependOnceListener(event: "end", listener: () => void): this
//     prependOnceListener(event: "readable", listener: () => void): this
//     prependOnceListener(event: "error", listener: (err: Error) => void): this

//     removeListener(event: "close", listener: () => void): this
//     removeListener(event: "data", listener: (chunk: Buffer | string) => void): this
//     removeListener(event: "end", listener: () => void): this
//     removeListener(event: "readable", listener: () => void): this
//     removeListener(event: "error", listener: (err: Error) => void): this
// }

// interface WritableEventEmitter extends EventEmitter {
//     /**
//      * Event emitter
//      * The defined events on documents including:
//      * 1. close
//      * 2. drain
//      * 3. error
//      * 4. finish
//      * 5. pipe
//      * 6. unpipe
//      */
//     addListener(event: "close", listener: () => void): this
//     addListener(event: "drain", listener: () => void): this
//     addListener(event: "error", listener: (err: Error) => void): this
//     addListener(event: "finish", listener: () => void): this
//     addListener(event: "pipe", listener: (src: Readable) => void): this
//     addListener(event: "unpipe", listener: (src: Readable) => void): this

//     emit(event: "close"): boolean
//     emit(event: "drain", chunk: Buffer | string): boolean
//     emit(event: "error", err: Error): boolean
//     emit(event: "finish"): boolean
//     emit(event: "pipe", src: Readable): boolean
//     emit(event: "unpipe", src: Readable): boolean

//     on(event: "close", listener: () => void): this
//     on(event: "drain", listener: () => void): this
//     on(event: "error", listener: (err: Error) => void): this
//     on(event: "finish", listener: () => void): this
//     on(event: "pipe", listener: (src: Readable) => void): this
//     on(event: "unpipe", listener: (src: Readable) => void): this

//     once(event: "close", listener: () => void): this
//     once(event: "drain", listener: () => void): this
//     once(event: "error", listener: (err: Error) => void): this
//     once(event: "finish", listener: () => void): this
//     once(event: "pipe", listener: (src: Readable) => void): this
//     once(event: "unpipe", listener: (src: Readable) => void): this

//     prependListener(event: "close", listener: () => void): this
//     prependListener(event: "drain", listener: () => void): this
//     prependListener(event: "error", listener: (err: Error) => void): this
//     prependListener(event: "finish", listener: () => void): this
//     prependListener(event: "pipe", listener: (src: Readable) => void): this
//     prependListener(event: "unpipe", listener: (src: Readable) => void): this

//     prependOnceListener(event: "close", listener: () => void): this
//     prependOnceListener(event: "drain", listener: () => void): this
//     prependOnceListener(event: "error", listener: (err: Error) => void): this
//     prependOnceListener(event: "finish", listener: () => void): this
//     prependOnceListener(event: "pipe", listener: (src: Readable) => void): this
//     prependOnceListener(event: "unpipe", listener: (src: Readable) => void): this

//     removeListener(event: "close", listener: () => void): this
//     removeListener(event: "drain", listener: () => void): this
//     removeListener(event: "error", listener: (err: Error) => void): this
//     removeListener(event: "finish", listener: () => void): this
//     removeListener(event: "pipe", listener: (src: Readable) => void): this
//     removeListener(event: "unpipe", listener: (src: Readable) => void): this
// }

export interface ReadableOptions<T> {
    highWaterMark?: number
    encoding?: string
    objectMode?: boolean
    read?: (this: Readable<T>, size?: number) => T | null
    destroy?: DestroyFunc
}

export interface Readable<T> extends EventEmitter {
    readable: boolean
    _read(size: number): void
    read(size?: number): T
    setEncoding(encoding: string): this
    pause(): this
    resume(): this
    isPaused(): boolean
    pipe<T extends Writable<U>, U>(destination: T, options?: { end?: boolean }): T
    unpipe<T extends Writable<U>, U>(destination?: T): this
    unshift(chunk: T): void
    push(chunk: T, encoding?: string): boolean
    destroy(error?: Error): void
}

type WriteCallback = (error?: Error) => void
type WriteFunc<T> = (chunk: T, encoding: string, callback: WriteCallback) =>
void
type DestroyFunc = (error: Error, callback: WriteCallback) => void
type FinalFunc = (callback: WriteCallback) => void

export interface WritableOptions<T> {
    highWaterMark?: number
    decodeStrings?: boolean
    objectMode?: boolean
    write: WriteFunc<T>
    writev?: (chunks: Array<{ chunk: T, encoding: string }>,
      callback: WriteCallback) => void
    destroy?: DestroyFunc
    final?: FinalFunc
}

export interface Writable<T = string | Buffer> extends EventEmitter {
    writable: boolean
    _write: WriteFunc<T>
    _destroy: DestroyFunc
    _final: FinalFunc
    write(chunk: T, cb?: WriteCallback): boolean
    write(chunk: T, encoding?: string, cb?: WriteCallback): boolean
    setDefaultEncoding(encoding: string): this
    end(): void
    end(chunk: T, cb?: WriteCallback): void
    end(chunk: T, encoding?: string, cb?: WriteCallback): void
    cork(): void
    uncork(): void
    destroy(error?: Error): void
}

export interface DuplexOptions<W, R> extends ReadableOptions<R>, WritableOptions<W> {
    allowHalfOpen?: boolean
    readableObjectMode?: boolean
    writableObjectMode?: boolean
}

export interface Duplex<W, R> extends Readable<R>, Writable<W> {
}

type TransformFunc<W, R> = (chunk: W, encoding: string,
  callback: (error?: Error, chunk?: R) => void) => void

export interface TransformOptions<W, R> extends DuplexOptions<W, R> {
    transform?: TransformFunc<W, R>
    flush?: (callback: Function) => any
}

export interface Transform<W, R> extends Duplex<W, R> {
    _transform: TransformFunc<W, R>
    destroy(error?: Error): void
}

export interface PassThrough<T> extends Transform<T, T> { }


export function createWritable<T>(options: WritableOptions<T>): Writable<T> {

  return new stream.Writable(options as any) as Writable<T>
}

export function createReadable<T>(options: ReadableOptions<T>): Readable<T> {

  return new stream.Readable(options as any) as Readable<T>
}

export function createDuplex<W, R = W>(options: DuplexOptions<W, R>):
  Duplex<W, R> {

  return new stream.Duplex(options as any) as Duplex<W, R>
}

export function createTransform<W, R = W>(options: TransformOptions<W, R>):
  Transform<W, R> {

  return new stream.Transform(options as any) as Transform<W, R>
}