| var stream = require('readable-stream') |
| var eos = require('end-of-stream') |
| var inherits = require('inherits') |
| var shift = require('stream-shift') |
| |
| var SIGNAL_FLUSH = (Buffer.from && Buffer.from !== Uint8Array.from) |
| ? Buffer.from([0]) |
| : new Buffer([0]) |
| |
| var onuncork = function(self, fn) { |
| if (self._corked) self.once('uncork', fn) |
| else fn() |
| } |
| |
| var autoDestroy = function (self, err) { |
| if (self._autoDestroy) self.destroy(err) |
| } |
| |
| var destroyer = function(self, end) { |
| return function(err) { |
| if (err) autoDestroy(self, err.message === 'premature close' ? null : err) |
| else if (end && !self._ended) self.end() |
| } |
| } |
| |
| var end = function(ws, fn) { |
| if (!ws) return fn() |
| if (ws._writableState && ws._writableState.finished) return fn() |
| if (ws._writableState) return ws.end(fn) |
| ws.end() |
| fn() |
| } |
| |
| var toStreams2 = function(rs) { |
| return new (stream.Readable)({objectMode:true, highWaterMark:16}).wrap(rs) |
| } |
| |
| var Duplexify = function(writable, readable, opts) { |
| if (!(this instanceof Duplexify)) return new Duplexify(writable, readable, opts) |
| stream.Duplex.call(this, opts) |
| |
| this._writable = null |
| this._readable = null |
| this._readable2 = null |
| |
| this._autoDestroy = !opts || opts.autoDestroy !== false |
| this._forwardDestroy = !opts || opts.destroy !== false |
| this._forwardEnd = !opts || opts.end !== false |
| this._corked = 1 // start corked |
| this._ondrain = null |
| this._drained = false |
| this._forwarding = false |
| this._unwrite = null |
| this._unread = null |
| this._ended = false |
| |
| this.destroyed = false |
| |
| if (writable) this.setWritable(writable) |
| if (readable) this.setReadable(readable) |
| } |
| |
| inherits(Duplexify, stream.Duplex) |
| |
| Duplexify.obj = function(writable, readable, opts) { |
| if (!opts) opts = {} |
| opts.objectMode = true |
| opts.highWaterMark = 16 |
| return new Duplexify(writable, readable, opts) |
| } |
| |
| Duplexify.prototype.cork = function() { |
| if (++this._corked === 1) this.emit('cork') |
| } |
| |
| Duplexify.prototype.uncork = function() { |
| if (this._corked && --this._corked === 0) this.emit('uncork') |
| } |
| |
| Duplexify.prototype.setWritable = function(writable) { |
| if (this._unwrite) this._unwrite() |
| |
| if (this.destroyed) { |
| if (writable && writable.destroy) writable.destroy() |
| return |
| } |
| |
| if (writable === null || writable === false) { |
| this.end() |
| return |
| } |
| |
| var self = this |
| var unend = eos(writable, {writable:true, readable:false}, destroyer(this, this._forwardEnd)) |
| |
| var ondrain = function() { |
| var ondrain = self._ondrain |
| self._ondrain = null |
| if (ondrain) ondrain() |
| } |
| |
| var clear = function() { |
| self._writable.removeListener('drain', ondrain) |
| unend() |
| } |
| |
| if (this._unwrite) process.nextTick(ondrain) // force a drain on stream reset to avoid livelocks |
| |
| this._writable = writable |
| this._writable.on('drain', ondrain) |
| this._unwrite = clear |
| |
| this.uncork() // always uncork setWritable |
| } |
| |
| Duplexify.prototype.setReadable = function(readable) { |
| if (this._unread) this._unread() |
| |
| if (this.destroyed) { |
| if (readable && readable.destroy) readable.destroy() |
| return |
| } |
| |
| if (readable === null || readable === false) { |
| this.push(null) |
| this.resume() |
| return |
| } |
| |
| var self = this |
| var unend = eos(readable, {writable:false, readable:true}, destroyer(this)) |
| |
| var onreadable = function() { |
| self._forward() |
| } |
| |
| var onend = function() { |
| self.push(null) |
| } |
| |
| var clear = function() { |
| self._readable2.removeListener('readable', onreadable) |
| self._readable2.removeListener('end', onend) |
| unend() |
| } |
| |
| this._drained = true |
| this._readable = readable |
| this._readable2 = readable._readableState ? readable : toStreams2(readable) |
| this._readable2.on('readable', onreadable) |
| this._readable2.on('end', onend) |
| this._unread = clear |
| |
| this._forward() |
| } |
| |
| Duplexify.prototype._read = function() { |
| this._drained = true |
| this._forward() |
| } |
| |
| Duplexify.prototype._forward = function() { |
| if (this._forwarding || !this._readable2 || !this._drained) return |
| this._forwarding = true |
| |
| var data |
| |
| while (this._drained && (data = shift(this._readable2)) !== null) { |
| if (this.destroyed) continue |
| this._drained = this.push(data) |
| } |
| |
| this._forwarding = false |
| } |
| |
| Duplexify.prototype.destroy = function(err) { |
| if (this.destroyed) return |
| this.destroyed = true |
| |
| var self = this |
| process.nextTick(function() { |
| self._destroy(err) |
| }) |
| } |
| |
| Duplexify.prototype._destroy = function(err) { |
| if (err) { |
| var ondrain = this._ondrain |
| this._ondrain = null |
| if (ondrain) ondrain(err) |
| else this.emit('error', err) |
| } |
| |
| if (this._forwardDestroy) { |
| if (this._readable && this._readable.destroy) this._readable.destroy() |
| if (this._writable && this._writable.destroy) this._writable.destroy() |
| } |
| |
| this.emit('close') |
| } |
| |
| Duplexify.prototype._write = function(data, enc, cb) { |
| if (this.destroyed) return cb() |
| if (this._corked) return onuncork(this, this._write.bind(this, data, enc, cb)) |
| if (data === SIGNAL_FLUSH) return this._finish(cb) |
| if (!this._writable) return cb() |
| |
| if (this._writable.write(data) === false) this._ondrain = cb |
| else cb() |
| } |
| |
| Duplexify.prototype._finish = function(cb) { |
| var self = this |
| this.emit('preend') |
| onuncork(this, function() { |
| end(self._forwardEnd && self._writable, function() { |
| // haxx to not emit prefinish twice |
| if (self._writableState.prefinished === false) self._writableState.prefinished = true |
| self.emit('prefinish') |
| onuncork(self, cb) |
| }) |
| }) |
| } |
| |
| Duplexify.prototype.end = function(data, enc, cb) { |
| if (typeof data === 'function') return this.end(null, null, data) |
| if (typeof enc === 'function') return this.end(data, null, enc) |
| this._ended = true |
| if (data) this.write(data) |
| if (!this._writableState.ending) this.write(SIGNAL_FLUSH) |
| return stream.Writable.prototype.end.call(this, cb) |
| } |
| |
| module.exports = Duplexify |