twitst4tz

index.js (5562B)

---

 /*!
  * type-is
  * Copyright(c) 2014 Jonathan Ong
  * Copyright(c) 2014-2015 Douglas Christopher Wilson
  * MIT Licensed
  */
 
 'use strict'
 
 /**
  * Module dependencies.
  * @private
  */
 
 var typer = require('media-typer')
 var mime = require('mime-types')
 
 /**
  * Module exports.
  * @public
  */
 
 module.exports = typeofrequest
 module.exports.is = typeis
 module.exports.hasBody = hasbody
 module.exports.normalize = normalize
 module.exports.match = mimeMatch
 
 /**
  * Compare a `value` content-type with `types`.
  * Each `type` can be an extension like `html`,
  * a special shortcut like `multipart` or `urlencoded`,
  * or a mime type.
  *
  * If no types match, `false` is returned.
  * Otherwise, the first `type` that matches is returned.
  *
  * @param {String} value
  * @param {Array} types
  * @public
  */
 
 function typeis (value, types_) {
   var i
   var types = types_
 
   // remove parameters and normalize
   var val = tryNormalizeType(value)
 
   // no type or invalid
   if (!val) {
     return false
   }
 
   // support flattened arguments
   if (types && !Array.isArray(types)) {
     types = new Array(arguments.length - 1)
     for (i = 0; i < types.length; i++) {
       types[i] = arguments[i + 1]
     }
   }
 
   // no types, return the content type
   if (!types || !types.length) {
     return val
   }
 
   var type
   for (i = 0; i < types.length; i++) {
     if (mimeMatch(normalize(type = types[i]), val)) {
       return type[0] === '+' || type.indexOf('*') !== -1
         ? val
         : type
     }
   }
 
   // no matches
   return false
 }
 
 /**
  * Check if a request has a request body.
  * A request with a body __must__ either have `transfer-encoding`
  * or `content-length` headers set.
  * http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.3
  *
  * @param {Object} request
  * @return {Boolean}
  * @public
  */
 
 function hasbody (req) {
   return req.headers['transfer-encoding'] !== undefined ||
     !isNaN(req.headers['content-length'])
 }
 
 /**
  * Check if the incoming request contains the "Content-Type"
  * header field, and it contains any of the give mime `type`s.
  * If there is no request body, `null` is returned.
  * If there is no content type, `false` is returned.
  * Otherwise, it returns the first `type` that matches.
  *
  * Examples:
  *
  *     // With Content-Type: text/html; charset=utf-8
  *     this.is('html'); // => 'html'
  *     this.is('text/html'); // => 'text/html'
  *     this.is('text/*', 'application/json'); // => 'text/html'
  *
  *     // When Content-Type is application/json
  *     this.is('json', 'urlencoded'); // => 'json'
  *     this.is('application/json'); // => 'application/json'
  *     this.is('html', 'application/*'); // => 'application/json'
  *
  *     this.is('html'); // => false
  *
  * @param {String|Array} types...
  * @return {String|false|null}
  * @public
  */
 
 function typeofrequest (req, types_) {
   var types = types_
 
   // no body
   if (!hasbody(req)) {
     return null
   }
 
   // support flattened arguments
   if (arguments.length > 2) {
     types = new Array(arguments.length - 1)
     for (var i = 0; i < types.length; i++) {
       types[i] = arguments[i + 1]
     }
   }
 
   // request content type
   var value = req.headers['content-type']
 
   return typeis(value, types)
 }
 
 /**
  * Normalize a mime type.
  * If it's a shorthand, expand it to a valid mime type.
  *
  * In general, you probably want:
  *
  *   var type = is(req, ['urlencoded', 'json', 'multipart']);
  *
  * Then use the appropriate body parsers.
  * These three are the most common request body types
  * and are thus ensured to work.
  *
  * @param {String} type
  * @private
  */
 
 function normalize (type) {
   if (typeof type !== 'string') {
     // invalid type
     return false
   }
 
   switch (type) {
     case 'urlencoded':
       return 'application/x-www-form-urlencoded'
     case 'multipart':
       return 'multipart/*'
   }
 
   if (type[0] === '+') {
     // "+json" -> "*/*+json" expando
     return '*/*' + type
   }
 
   return type.indexOf('/') === -1
     ? mime.lookup(type)
     : type
 }
 
 /**
  * Check if `expected` mime type
  * matches `actual` mime type with
  * wildcard and +suffix support.
  *
  * @param {String} expected
  * @param {String} actual
  * @return {Boolean}
  * @private
  */
 
 function mimeMatch (expected, actual) {
   // invalid type
   if (expected === false) {
     return false
   }
 
   // split types
   var actualParts = actual.split('/')
   var expectedParts = expected.split('/')
 
   // invalid format
   if (actualParts.length !== 2 || expectedParts.length !== 2) {
     return false
   }
 
   // validate type
   if (expectedParts[0] !== '*' && expectedParts[0] !== actualParts[0]) {
     return false
   }
 
   // validate suffix wildcard
   if (expectedParts[1].substr(0, 2) === '*+') {
     return expectedParts[1].length <= actualParts[1].length + 1 &&
       expectedParts[1].substr(1) === actualParts[1].substr(1 - expectedParts[1].length)
   }
 
   // validate subtype
   if (expectedParts[1] !== '*' && expectedParts[1] !== actualParts[1]) {
     return false
   }
 
   return true
 }
 
 /**
  * Normalize a type and remove parameters.
  *
  * @param {string} value
  * @return {string}
  * @private
  */
 
 function normalizeType (value) {
   // parse the type
   var type = typer.parse(value)
 
   // remove the parameters
   type.parameters = undefined
 
   // reformat it
   return typer.format(type)
 }
 
 /**
  * Try to normalize a type and remove parameters.
  *
  * @param {string} value
  * @return {string}
  * @private
  */
 
 function tryNormalizeType (value) {
   if (!value) {
     return null
   }
 
   try {
     return normalizeType(value)
   } catch (err) {
     return null
   }
 }