BVB Source Codes

reactide Show index.js Source code

Return Download reactide: download index.js Source code - Download reactide Source code - Type:.js
  1. /*!
  2.  * accepts
  3.  * Copyright(c) 2014 Jonathan Ong
  4.  * Copyright(c) 2015 Douglas Christopher Wilson
  5.  * MIT Licensed
  6.  */
  7.  
  8. 'use strict'
  9.  
  10. /**
  11.  * Module dependencies.
  12.  * @private
  13.  */
  14.  
  15. var Negotiator = require('negotiator')
  16. var mime = require('mime-types')
  17.  
  18. /**
  19.  * Module exports.
  20.  * @public
  21.  */
  22.  
  23. module.exports = Accepts
  24.  
  25. /**
  26.  * Create a new Accepts object for the given req.
  27.  *
  28.  * @param {object} req
  29.  * @public
  30.  */
  31.  
  32. function Accepts(req) {
  33.   if (!(this instanceof Accepts))
  34.     return new Accepts(req)
  35.  
  36.   this.headers = req.headers
  37.   this.negotiator = new Negotiator(req)
  38. }
  39.  
  40. /**
  41.  * Check if the given `type(s)` is acceptable, returning
  42.  * the best match when true, otherwise `undefined`, in which
  43.  * case you should respond with 406 "Not Acceptable".
  44.  *
  45.  * The `type` value may be a single mime type string
  46.  * such as "application/json", the extension name
  47.  * such as "json" or an array `["json", "html", "text/plain"]`. When a list
  48.  * or array is given the _best_ match, if any is returned.
  49.  *
  50.  * Examples:
  51.  *
  52.  *     // Accept: text/html
  53.  *     this.types('html');
  54.  *     // => "html"
  55.  *
  56.  *     // Accept: text/*, application/json
  57.  *     this.types('html');
  58.  *     // => "html"
  59.  *     this.types('text/html');
  60.  *     // => "text/html"
  61.  *     this.types('json', 'text');
  62.  *     // => "json"
  63.  *     this.types('application/json');
  64.  *     // => "application/json"
  65.  *
  66.  *     // Accept: text/*, application/json
  67.  *     this.types('image/png');
  68.  *     this.types('png');
  69.  *     // => undefined
  70.  *
  71.  *     // Accept: text/*;q=.5, application/json
  72.  *     this.types(['html', 'json']);
  73.  *     this.types('html', 'json');
  74.  *     // => "json"
  75.  *
  76.  * @param {String|Array} types...
  77.  * @return {String|Array|Boolean}
  78.  * @public
  79.  */
  80.  
  81. Accepts.prototype.type =
  82. Accepts.prototype.types = function (types_) {
  83.   var types = types_
  84.  
  85.   // support flattened arguments
  86.   if (types && !Array.isArray(types)) {
  87.     types = new Array(arguments.length)
  88.     for (var i = 0; i < types.length; i++) {
  89.       types[i] = arguments[i]
  90.     }
  91.   }
  92.  
  93.   // no types, return all requested types
  94.   if (!types || types.length === 0) {
  95.     return this.negotiator.mediaTypes()
  96.   }
  97.  
  98.   if (!this.headers.accept) return types[0];
  99.   var mimes = types.map(extToMime);
  100.   var accepts = this.negotiator.mediaTypes(mimes.filter(validMime));
  101.   var first = accepts[0];
  102.   if (!first) return false;
  103.   return types[mimes.indexOf(first)];
  104. }
  105.  
  106. /**
  107.  * Return accepted encodings or best fit based on `encodings`.
  108.  *
  109.  * Given `Accept-Encoding: gzip, deflate`
  110.  * an array sorted by quality is returned:
  111.  *
  112.  *     ['gzip', 'deflate']
  113.  *
  114.  * @param {String|Array} encodings...
  115.  * @return {String|Array}
  116.  * @public
  117.  */
  118.  
  119. Accepts.prototype.encoding =
  120. Accepts.prototype.encodings = function (encodings_) {
  121.   var encodings = encodings_
  122.  
  123.   // support flattened arguments
  124.   if (encodings && !Array.isArray(encodings)) {
  125.     encodings = new Array(arguments.length)
  126.     for (var i = 0; i < encodings.length; i++) {
  127.       encodings[i] = arguments[i]
  128.     }
  129.   }
  130.  
  131.   // no encodings, return all requested encodings
  132.   if (!encodings || encodings.length === 0) {
  133.     return this.negotiator.encodings()
  134.   }
  135.  
  136.   return this.negotiator.encodings(encodings)[0] || false
  137. }
  138.  
  139. /**
  140.  * Return accepted charsets or best fit based on `charsets`.
  141.  *
  142.  * Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
  143.  * an array sorted by quality is returned:
  144.  *
  145.  *     ['utf-8', 'utf-7', 'iso-8859-1']
  146.  *
  147.  * @param {String|Array} charsets...
  148.  * @return {String|Array}
  149.  * @public
  150.  */
  151.  
  152. Accepts.prototype.charset =
  153. Accepts.prototype.charsets = function (charsets_) {
  154.   var charsets = charsets_
  155.  
  156.   // support flattened arguments
  157.   if (charsets && !Array.isArray(charsets)) {
  158.     charsets = new Array(arguments.length)
  159.     for (var i = 0; i < charsets.length; i++) {
  160.       charsets[i] = arguments[i]
  161.     }
  162.   }
  163.  
  164.   // no charsets, return all requested charsets
  165.   if (!charsets || charsets.length === 0) {
  166.     return this.negotiator.charsets()
  167.   }
  168.  
  169.   return this.negotiator.charsets(charsets)[0] || false
  170. }
  171.  
  172. /**
  173.  * Return accepted languages or best fit based on `langs`.
  174.  *
  175.  * Given `Accept-Language: en;q=0.8, es, pt`
  176.  * an array sorted by quality is returned:
  177.  *
  178.  *     ['es', 'pt', 'en']
  179.  *
  180.  * @param {String|Array} langs...
  181.  * @return {Array|String}
  182.  * @public
  183.  */
  184.  
  185. Accepts.prototype.lang =
  186. Accepts.prototype.langs =
  187. Accepts.prototype.language =
  188. Accepts.prototype.languages = function (languages_) {
  189.   var languages = languages_
  190.  
  191.   // support flattened arguments
  192.   if (languages && !Array.isArray(languages)) {
  193.     languages = new Array(arguments.length)
  194.     for (var i = 0; i < languages.length; i++) {
  195.       languages[i] = arguments[i]
  196.     }
  197.   }
  198.  
  199.   // no languages, return all requested languages
  200.   if (!languages || languages.length === 0) {
  201.     return this.negotiator.languages()
  202.   }
  203.  
  204.   return this.negotiator.languages(languages)[0] || false
  205. }
  206.  
  207. /**
  208.  * Convert extnames to mime.
  209.  *
  210.  * @param {String} type
  211.  * @return {String}
  212.  * @private
  213.  */
  214.  
  215. function extToMime(type) {
  216.   return type.indexOf('/') === -1
  217.     ? mime.lookup(type)
  218.     : type
  219. }
  220.  
  221. /**
  222.  * Check if mime is valid.
  223.  *
  224.  * @param {String} type
  225.  * @return {String}
  226.  * @private
  227.  */
  228.  
  229. function validMime(type) {
  230.   return typeof type === 'string';
  231. }
  232.  
downloadindex.js Source code - Download reactide Source code
Related Source Codes/Software:
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
postal - 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top