@fab/input-nextjs/shims/mock-express-response/utils.js

/*!
 * express
 * Copyright(c) 2009-2013 TJ Holowaychuk
 * Copyright(c) 2014-2015 Douglas Christopher Wilson
 * MIT Licensed
 */

/**
 * Module dependencies.
 * @api private
 */

var contentDisposition = require('content-disposition')
var contentType = require('content-type')
var deprecate = require('depd')('express')
var mime = require('send').mime
var basename = require('path').basename
var etag = require('etag')
var proxyaddr = require('proxy-addr')
var qs = require('qs')
var querystring = require('querystring')

/**
 * Return strong ETag for `body`.
 *
 * @param {String|Buffer} body
 * @param {String} [encoding]
 * @return {String}
 * @api private
 */

exports.etag = function(body, encoding) {
  var buf = !Buffer.isBuffer(body) ? new Buffer(body, encoding) : body

  return etag(buf, { weak: false })
}

/**
 * Return weak ETag for `body`.
 *
 * @param {String|Buffer} body
 * @param {String} [encoding]
 * @return {String}
 * @api private
 */

exports.wetag = function wetag(body, encoding) {
  var buf = !Buffer.isBuffer(body) ? new Buffer(body, encoding) : body

  return etag(buf, { weak: true })
}

/**
 * Check if `path` looks absolute.
 *
 * @param {String} path
 * @return {Boolean}
 * @api private
 */

exports.isAbsolute = function(path) {
  if ('/' == path[0]) return true
  if (':' == path[1] && '\\' == path[2]) return true
  if ('\\\\' == path.substring(0, 2)) return true // Microsoft Azure absolute path
}

/**
 * Flatten the given `arr`.
 *
 * @param {Array} arr
 * @return {Array}
 * @api private
 */

exports.flatten = function(arr, ret) {
  ret = ret || []
  var len = arr.length
  for (var i = 0; i < len; ++i) {
    if (Array.isArray(arr[i])) {
      exports.flatten(arr[i], ret)
    } else {
      ret.push(arr[i])
    }
  }
  return ret
}

/**
 * Normalize the given `type`, for example "html" becomes "text/html".
 *
 * @param {String} type
 * @return {Object}
 * @api private
 */

exports.normalizeType = function(type) {
  return ~type.indexOf('/')
    ? acceptParams(type)
    : { value: mime.lookup(type), params: {} }
}

/**
 * Normalize `types`, for example "html" becomes "text/html".
 *
 * @param {Array} types
 * @return {Array}
 * @api private
 */

exports.normalizeTypes = function(types) {
  var ret = []

  for (var i = 0; i < types.length; ++i) {
    ret.push(exports.normalizeType(types[i]))
  }

  return ret
}

/**
 * Generate Content-Disposition header appropriate for the filename.
 * non-ascii filenames are urlencoded and a filename* parameter is added
 *
 * @param {String} filename
 * @return {String}
 * @api private
 */

exports.contentDisposition = deprecate.function(
  contentDisposition,
  'utils.contentDisposition: use content-disposition npm module instead'
)

/**
 * Parse accept params `str` returning an
 * object with `.value`, `.quality` and `.params`.
 * also includes `.originalIndex` for stable sorting
 *
 * @param {String} str
 * @return {Object}
 * @api private
 */

function acceptParams(str, index) {
  var parts = str.split(/ *; */)
  var ret = { value: parts[0], quality: 1, params: {}, originalIndex: index }

  for (var i = 1; i < parts.length; ++i) {
    var pms = parts[i].split(/ *= */)
    if ('q' == pms[0]) {
      ret.quality = parseFloat(pms[1])
    } else {
      ret.params[pms[0]] = pms[1]
    }
  }

  return ret
}

/**
 * Compile "etag" value to function.
 *
 * @param  {Boolean|String|Function} val
 * @return {Function}
 * @api private
 */

exports.compileETag = function(val) {
  var fn

  if (typeof val === 'function') {
    return val
  }

  switch (val) {
    case true:
      fn = exports.wetag
      break
    case false:
      break
    case 'strong':
      fn = exports.etag
      break
    case 'weak':
      fn = exports.wetag
      break
    default:
      throw new TypeError('unknown value for etag function: ' + val)
  }

  return fn
}

/**
 * Compile "query parser" value to function.
 *
 * @param  {String|Function} val
 * @return {Function}
 * @api private
 */

exports.compileQueryParser = function compileQueryParser(val) {
  var fn

  if (typeof val === 'function') {
    return val
  }

  switch (val) {
    case true:
      fn = querystring.parse
      break
    case false:
      fn = newObject
      break
    case 'extended':
      fn = qs.parse
      break
    case 'simple':
      fn = querystring.parse
      break
    default:
      throw new TypeError('unknown value for query parser function: ' + val)
  }

  return fn
}

/**
 * Compile "proxy trust" value to function.
 *
 * @param  {Boolean|String|Number|Array|Function} val
 * @return {Function}
 * @api private
 */

exports.compileTrust = function(val) {
  if (typeof val === 'function') return val

  if (val === true) {
    // Support plain true/false
    return function() {
      return true
    }
  }

  if (typeof val === 'number') {
    // Support trusting hop count
    return function(a, i) {
      return i < val
    }
  }

  if (typeof val === 'string') {
    // Support comma-separated values
    val = val.split(/ *, */)
  }

  return proxyaddr.compile(val || [])
}

/**
 * Set the charset in a given Content-Type string.
 *
 * @param {String} type
 * @param {String} charset
 * @return {String}
 * @api private
 */

exports.setCharset = function setCharset(type, charset) {
  if (!type || !charset) {
    return type
  }

  // parse type
  var parsed = contentType.parse(type)

  // set charset
  parsed.parameters.charset = charset

  // format type
  return contentType.format(parsed)
}

/**
 * Return new empty object.
 *
 * @return {Object}
 * @api private
 */

function newObject() {
  return {}
}