1. module compression
   1. function compression (options)
   2. function compression.filter (req, res)

module compression

function compression (options)

• description and source-code

  function compression(options) {
    var opts = options || {}
  
    // options
    var filter = opts.filter || shouldCompress
    var threshold = bytes.parse(opts.threshold)
  
    if (threshold == null) {
      threshold = 1024
    }
  
    return function compression (req, res, next) {
      var ended = false
      var length
      var listeners = []
      var stream
  
      var _end = res.end
      var _on = res.on
      var _write = res.write
  
      // flush
      res.flush = function flush () {
        if (stream) {
          stream.flush()
        }
      }
  
      // proxy
  
      res.write = function write (chunk, encoding) {
        if (ended) {
          return false
        }
  
        if (!this._header) {
          this._implicitHeader()
        }
  
        return stream
          ? stream.write(new Buffer(chunk, encoding))
          : _write.call(this, chunk, encoding)
      }
  
      res.end = function end (chunk, encoding) {
        if (ended) {
          return false
        }
  
        if (!this._header) {
          // estimate the length
          if (!this.getHeader('Content-Length')) {
            length = chunkLength(chunk, encoding)
          }
  
          this._implicitHeader()
        }
  
        if (!stream) {
          return _end.call(this, chunk, encoding)
        }
  
        // mark ended
        ended = true
  
        // write Buffer for Node.js 0.8
        return chunk
          ? stream.end(new Buffer(chunk, encoding))
          : stream.end()
      }
  
      res.on = function on (type, listener) {
        if (!listeners || type !== 'drain') {
          return _on.call(this, type, listener)
        }
  
        if (stream) {
          return stream.on(type, listener)
        }
  
        // buffer listeners for future stream
        listeners.push([type, listener])
  
        return this
      }
  
      function nocompress (msg) {
        debug('no compression: %s', msg)
        addListeners(res, _on, listeners)
        listeners = null
      }
  
      onHeaders(res, function onResponseHeaders () {
        // determine if request is filtered
        if (!filter(req, res)) {
          nocompress('filtered')
          return
        }
  
        // determine if the entity should be transformed
        if (!shouldTransform(req, res)) {
          nocompress('no transform')
          return
        }
  
        // vary
        vary(res, 'Accept-Encoding')
  
        // content-length below threshold
        if (Number(res.getHeader('Content-Length')) < threshold || length < threshold) {
          nocompress('size below threshold')
          return
        }
  
        var encoding = res.getHeader('Content-Encoding') || 'identity'
  
        // already encoded
        if (encoding !== 'identity') {
          nocompress('already encoded')
          return
        }
  
        // head
        if (req.method === 'HEAD') {
          nocompress('HEAD request')
          return
        }
  
        // compression method
        var accept = accepts(req)
        var method = accept.encoding(['gzip', 'deflate', 'identity'])
  
        // we really don't prefer deflate
        if (method === 'deflate' && accept.encoding(['gzip'])) {
          method = accept.encoding(['gzip', 'identity'])
        }
  
        // negotiation failed
        if (!method || method === 'identity') {
          nocompress('not acceptable')
          return
        }
  
        // compression stream
        debug('%s compression', method)
        stream = method === 'gzip'
          ? zlib.createGzip(opts)
          : zlib.createDeflate(opts)
  
        // add buffered listeners to stream
        addListeners(stream, stream.on, listeners)
  
        // header fields
        res.setHeader('Content-Encoding', method)
        res.removeHeader('Content-Length')
  
        // compression
        stream.on('data', function onStreamData (chunk) {
          if (_write.call(res, chunk) === false) {
            stream.pause()
          }
        })
  
        stream.on('end', function onStreamEnd () {
          _end.call(res)
        })
  
        _on.call(res, 'drain', function onResponseDrain () {
          stream.resume()
        })
      })
  
      next()
    }
  }

• example usage

  n/a

function compression.filter (req, res)

• description and source-code

  function shouldCompress(req, res) {
    var type = res.getHeader('Content-Type')
  
    if (type === undefined || !compressible(type)) {
      debug('%s not compressible', type)
      return false
    }
  
    return true
  }

• example usage

  ...
  function shouldCompress(req, res) {
    if (req.headers['x-no-compression']) {
      // don't compress responses with this request header
      return false
    }
  
    // fallback to standard filter function
    return compression.filter(req, res)
  }
  ```
  
  ### res.flush
  
  This module adds a `res.flush()` method to force the partially-compressed
  response to be flushed to the client.
  ...