| /** |
| * negotiator |
| * Copyright(c) 2012 Isaac Z. Schlueter |
| * Copyright(c) 2014 Federico Romero |
| * Copyright(c) 2014-2015 Douglas Christopher Wilson |
| * MIT Licensed |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * Module exports. |
| * @public |
| */ |
| |
| module.exports = preferredMediaTypes; |
| module.exports.preferredMediaTypes = preferredMediaTypes; |
| |
| /** |
| * Module variables. |
| * @private |
| */ |
| |
| var simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/; |
| |
| /** |
| * Parse the Accept header. |
| * @private |
| */ |
| |
| function parseAccept(accept) { |
| var accepts = splitMediaTypes(accept); |
| |
| for (var i = 0, j = 0; i < accepts.length; i++) { |
| var mediaType = parseMediaType(accepts[i].trim(), i); |
| |
| if (mediaType) { |
| accepts[j++] = mediaType; |
| } |
| } |
| |
| // trim accepts |
| accepts.length = j; |
| |
| return accepts; |
| } |
| |
| /** |
| * Parse a media type from the Accept header. |
| * @private |
| */ |
| |
| function parseMediaType(str, i) { |
| var match = simpleMediaTypeRegExp.exec(str); |
| if (!match) return null; |
| |
| var params = Object.create(null); |
| var q = 1; |
| var subtype = match[2]; |
| var type = match[1]; |
| |
| if (match[3]) { |
| var kvps = splitParameters(match[3]).map(splitKeyValuePair); |
| |
| for (var j = 0; j < kvps.length; j++) { |
| var pair = kvps[j]; |
| var key = pair[0].toLowerCase(); |
| var val = pair[1]; |
| |
| // get the value, unwrapping quotes |
| var value = val && val[0] === '"' && val[val.length - 1] === '"' |
| ? val.substr(1, val.length - 2) |
| : val; |
| |
| if (key === 'q') { |
| q = parseFloat(value); |
| break; |
| } |
| |
| // store parameter |
| params[key] = value; |
| } |
| } |
| |
| return { |
| type: type, |
| subtype: subtype, |
| params: params, |
| q: q, |
| i: i |
| }; |
| } |
| |
| /** |
| * Get the priority of a media type. |
| * @private |
| */ |
| |
| function getMediaTypePriority(type, accepted, index) { |
| var priority = {o: -1, q: 0, s: 0}; |
| |
| for (var i = 0; i < accepted.length; i++) { |
| var spec = specify(type, accepted[i], index); |
| |
| if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) { |
| priority = spec; |
| } |
| } |
| |
| return priority; |
| } |
| |
| /** |
| * Get the specificity of the media type. |
| * @private |
| */ |
| |
| function specify(type, spec, index) { |
| var p = parseMediaType(type); |
| var s = 0; |
| |
| if (!p) { |
| return null; |
| } |
| |
| if(spec.type.toLowerCase() == p.type.toLowerCase()) { |
| s |= 4 |
| } else if(spec.type != '*') { |
| return null; |
| } |
| |
| if(spec.subtype.toLowerCase() == p.subtype.toLowerCase()) { |
| s |= 2 |
| } else if(spec.subtype != '*') { |
| return null; |
| } |
| |
| var keys = Object.keys(spec.params); |
| if (keys.length > 0) { |
| if (keys.every(function (k) { |
| return spec.params[k] == '*' || (spec.params[k] || '').toLowerCase() == (p.params[k] || '').toLowerCase(); |
| })) { |
| s |= 1 |
| } else { |
| return null |
| } |
| } |
| |
| return { |
| i: index, |
| o: spec.i, |
| q: spec.q, |
| s: s, |
| } |
| } |
| |
| /** |
| * Get the preferred media types from an Accept header. |
| * @public |
| */ |
| |
| function preferredMediaTypes(accept, provided) { |
| // RFC 2616 sec 14.2: no header = */* |
| var accepts = parseAccept(accept === undefined ? '*/*' : accept || ''); |
| |
| if (!provided) { |
| // sorted list of all types |
| return accepts |
| .filter(isQuality) |
| .sort(compareSpecs) |
| .map(getFullType); |
| } |
| |
| var priorities = provided.map(function getPriority(type, index) { |
| return getMediaTypePriority(type, accepts, index); |
| }); |
| |
| // sorted list of accepted types |
| return priorities.filter(isQuality).sort(compareSpecs).map(function getType(priority) { |
| return provided[priorities.indexOf(priority)]; |
| }); |
| } |
| |
| /** |
| * Compare two specs. |
| * @private |
| */ |
| |
| function compareSpecs(a, b) { |
| return (b.q - a.q) || (b.s - a.s) || (a.o - b.o) || (a.i - b.i) || 0; |
| } |
| |
| /** |
| * Get full type string. |
| * @private |
| */ |
| |
| function getFullType(spec) { |
| return spec.type + '/' + spec.subtype; |
| } |
| |
| /** |
| * Check if a spec has any quality. |
| * @private |
| */ |
| |
| function isQuality(spec) { |
| return spec.q > 0; |
| } |
| |
| /** |
| * Count the number of quotes in a string. |
| * @private |
| */ |
| |
| function quoteCount(string) { |
| var count = 0; |
| var index = 0; |
| |
| while ((index = string.indexOf('"', index)) !== -1) { |
| count++; |
| index++; |
| } |
| |
| return count; |
| } |
| |
| /** |
| * Split a key value pair. |
| * @private |
| */ |
| |
| function splitKeyValuePair(str) { |
| var index = str.indexOf('='); |
| var key; |
| var val; |
| |
| if (index === -1) { |
| key = str; |
| } else { |
| key = str.substr(0, index); |
| val = str.substr(index + 1); |
| } |
| |
| return [key, val]; |
| } |
| |
| /** |
| * Split an Accept header into media types. |
| * @private |
| */ |
| |
| function splitMediaTypes(accept) { |
| var accepts = accept.split(','); |
| |
| for (var i = 1, j = 0; i < accepts.length; i++) { |
| if (quoteCount(accepts[j]) % 2 == 0) { |
| accepts[++j] = accepts[i]; |
| } else { |
| accepts[j] += ',' + accepts[i]; |
| } |
| } |
| |
| // trim accepts |
| accepts.length = j + 1; |
| |
| return accepts; |
| } |
| |
| /** |
| * Split a string of parameters. |
| * @private |
| */ |
| |
| function splitParameters(str) { |
| var parameters = str.split(';'); |
| |
| for (var i = 1, j = 0; i < parameters.length; i++) { |
| if (quoteCount(parameters[j]) % 2 == 0) { |
| parameters[++j] = parameters[i]; |
| } else { |
| parameters[j] += ';' + parameters[i]; |
| } |
| } |
| |
| // trim parameters |
| parameters.length = j + 1; |
| |
| for (var i = 0; i < parameters.length; i++) { |
| parameters[i] = parameters[i].trim(); |
| } |
| |
| return parameters; |
| } |