BJ_web_developers / dyitoc

  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