npm package: @justinbeckwith/duplexify
Description: Turn a writable and readable stream into a streams2 duplex stream with support for async initialization and streams1/streams2 input
Author: Justin Beckwith
Latest version: 4.0.0

# @justinbeckwith/duplexify
> Turn a writeable and readable stream into a single streams2 duplex stream.

[![npm version](https://img.shields.io/npm/v/@justinbeckwith/duplexify.svg)](https://www.npmjs.org/package/@justinbeckwith/duplexify)
[![Build Status](https://api.cirrus-ci.com/github/JustinBeckwith/duplexify.svg)](https://cirrus-ci.com/github/JustinBeckwith/duplexify)
[![codecov](https://codecov.io/gh/JustinBeckwith/duplexify/branch/master/graph/badge.svg)](https://codecov.io/gh/JustinBeckwith/duplexify)
[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
[![Code Style: Google](https://img.shields.io/badge/code%20style-google-blueviolet.svg)](https://github.com/google/gts)

### Compare to `duplexify`
This is a fork of [duplexify](https://github.com/mafintosh/duplexify).  It does a few things different:
- Doesn't take a dependency on the user space ReadableStream npm module (this is smaller)
- Uses TypeScript for type safety

## Installation

```
npm install @justinbeckwith/duplexify
```

## Usage
Use `duplexify(writable, readable, streamOptions)` (or `duplexify.obj(writable, readable)` to create an object stream)

``` js
const {duplexify} = require('@justinbeckwith/duplexify')

// turn writableStream and readableStream into a single duplex stream
const dup = duplexify(writableStream, readableStream)

dup.write('hello world') // will write to writableStream
dup.on('data', (data) => {
  // will read from readableStream
})
```

You can also set the readable and writable parts asynchronously

``` js
const dup = duplexify()

dup.write('hello world') // write will buffer until the writable
                         // part has been set

// wait a bit ...
dup.setReadable(readableStream)

// maybe wait some more?
dup.setWritable(writableStream)
```

If you call `setReadable` or `setWritable` multiple times it will unregister the previous readable/writable stream.
To disable the readable or writable part call `setReadable` or `setWritable` with `null`.

If the readable or writable streams emits an error or close it will destroy both streams and bubble up the event.
You can also explicitly destroy the streams by calling `dup.destroy()`. The `destroy` method optionally takes an
error object as argument, in which case the error is emitted as part of the `error` event.

``` js
dup.on('error', (err) => {
  console.log('readable or writable emitted an error - close will follow')
})

dup.on('close', () => {
  console.log('the duplex stream is destroyed')
})

dup.destroy() // calls destroy on the readable and writable part (if present)
```

## HTTP request example

Turn a node core http request into a duplex stream is as easy as

``` js
const {duplexify} = require('duplexify')
const http = require('http')

const request = (opts) => {
  const req = http.request(opts)
  const dup = duplexify(req)
  req.on('response', (res) => {
    dup.setReadable(res)
  })
  return dup
}

const req = request({
  method: 'GET',
  host: 'www.google.com',
  port: 80
})

req.end()
req.pipe(process.stdout)
```

## License
MIT