2016-04-05 10:43:12 -07:00
|
|
|
|
2015-01-27 05:11:26 -08:00
|
|
|
/**
|
|
|
|
* headers.js
|
|
|
|
*
|
|
|
|
* Headers class offers convenient helpers
|
|
|
|
*/
|
|
|
|
|
2016-11-23 11:17:42 -08:00
|
|
|
import { checkIsHttpToken, checkInvalidHeaderChar } from './common.js';
|
2016-10-10 15:32:56 -07:00
|
|
|
|
|
|
|
function sanitizeName(name) {
|
|
|
|
name += '';
|
2016-11-23 11:17:42 -08:00
|
|
|
if (!checkIsHttpToken(name)) {
|
2016-10-10 15:32:56 -07:00
|
|
|
throw new TypeError(`${name} is not a legal HTTP header name`);
|
|
|
|
}
|
|
|
|
return name.toLowerCase();
|
|
|
|
}
|
|
|
|
|
|
|
|
function sanitizeValue(value) {
|
|
|
|
value += '';
|
2016-11-23 11:17:42 -08:00
|
|
|
if (checkInvalidHeaderChar(value)) {
|
2016-10-10 15:32:56 -07:00
|
|
|
throw new TypeError(`${value} is not a legal HTTP header value`);
|
|
|
|
}
|
|
|
|
return value;
|
|
|
|
}
|
2016-10-08 20:51:01 -07:00
|
|
|
|
2016-10-10 15:32:56 -07:00
|
|
|
export const MAP = Symbol('map');
|
2016-10-10 18:31:53 -07:00
|
|
|
const FOLLOW_SPEC = Symbol('followSpec');
|
2016-10-08 20:51:01 -07:00
|
|
|
export default class Headers {
|
|
|
|
/**
|
|
|
|
* Headers class
|
|
|
|
*
|
|
|
|
* @param Object headers Response headers
|
|
|
|
* @return Void
|
|
|
|
*/
|
|
|
|
constructor(headers) {
|
2016-10-15 10:02:52 -07:00
|
|
|
this[MAP] = Object.create(null);
|
2016-10-10 18:31:53 -07:00
|
|
|
this[FOLLOW_SPEC] = Headers.FOLLOW_SPEC;
|
2016-10-08 20:51:01 -07:00
|
|
|
|
2016-10-10 15:04:16 -07:00
|
|
|
// Headers
|
|
|
|
if (headers instanceof Headers) {
|
|
|
|
let init = headers.raw();
|
|
|
|
for (let name of Object.keys(init)) {
|
|
|
|
for (let value of init[name]) {
|
|
|
|
this.append(name, value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (Array.isArray(headers)) {
|
2016-10-10 13:49:12 -07:00
|
|
|
// array of tuples
|
|
|
|
for (let el of headers) {
|
|
|
|
if (!Array.isArray(el) || el.length !== 2) {
|
|
|
|
throw new TypeError('Header pairs must contain exactly two items');
|
|
|
|
}
|
|
|
|
this.append(el[0], el[1]);
|
|
|
|
}
|
2016-10-10 15:04:16 -07:00
|
|
|
} else if (typeof headers === 'object') {
|
|
|
|
// plain object
|
|
|
|
for (const prop of Object.keys(headers)) {
|
|
|
|
// We don't worry about converting prop to ByteString here as append()
|
|
|
|
// will handle it.
|
|
|
|
this.append(prop, headers[prop]);
|
2016-10-08 20:51:01 -07:00
|
|
|
}
|
|
|
|
}
|
2016-11-23 14:36:08 -08:00
|
|
|
|
|
|
|
Object.defineProperty(this, Symbol.toStringTag, {
|
|
|
|
value: 'Headers',
|
|
|
|
writable: false,
|
|
|
|
enumerable: false,
|
|
|
|
configurable: true
|
|
|
|
});
|
2016-10-08 20:51:01 -07:00
|
|
|
}
|
2015-01-27 05:11:26 -08:00
|
|
|
|
2016-10-08 20:51:01 -07:00
|
|
|
/**
|
|
|
|
* Return first header value given name
|
|
|
|
*
|
|
|
|
* @param String name Header name
|
|
|
|
* @return Mixed
|
|
|
|
*/
|
|
|
|
get(name) {
|
2016-10-10 15:32:56 -07:00
|
|
|
const list = this[MAP][sanitizeName(name)];
|
2016-10-10 18:31:53 -07:00
|
|
|
if (!list) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
return this[FOLLOW_SPEC] ? list.join(',') : list[0];
|
2015-04-22 08:36:11 -07:00
|
|
|
}
|
|
|
|
|
2016-10-08 20:51:01 -07:00
|
|
|
/**
|
|
|
|
* Return all header values given name
|
|
|
|
*
|
|
|
|
* @param String name Header name
|
|
|
|
* @return Array
|
|
|
|
*/
|
|
|
|
getAll(name) {
|
|
|
|
if (!this.has(name)) {
|
|
|
|
return [];
|
2015-03-19 08:38:27 -07:00
|
|
|
}
|
|
|
|
|
2016-10-10 15:32:56 -07:00
|
|
|
return this[MAP][sanitizeName(name)];
|
2016-10-08 20:51:01 -07:00
|
|
|
}
|
2015-05-03 21:05:06 -07:00
|
|
|
|
2016-10-08 20:51:01 -07:00
|
|
|
/**
|
|
|
|
* Iterate over all headers
|
|
|
|
*
|
|
|
|
* @param Function callback Executed for each item with parameters (value, name, thisArg)
|
|
|
|
* @param Boolean thisArg `this` context for callback function
|
|
|
|
* @return Void
|
|
|
|
*/
|
2016-11-23 15:06:30 -08:00
|
|
|
forEach(callback, thisArg = undefined) {
|
|
|
|
let pairs = getHeaderPairs(this);
|
|
|
|
let i = 0;
|
|
|
|
while (i < pairs.length) {
|
|
|
|
const [name, value] = pairs[i];
|
|
|
|
callback.call(thisArg, value, name, this);
|
|
|
|
pairs = getHeaderPairs(this);
|
|
|
|
i++;
|
2016-10-15 10:02:52 -07:00
|
|
|
}
|
2016-10-08 20:51:01 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Overwrite header values given name
|
|
|
|
*
|
|
|
|
* @param String name Header name
|
|
|
|
* @param String value Header value
|
|
|
|
* @return Void
|
|
|
|
*/
|
|
|
|
set(name, value) {
|
2016-10-10 15:32:56 -07:00
|
|
|
this[MAP][sanitizeName(name)] = [sanitizeValue(value)];
|
2016-10-08 20:51:01 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Append a value onto existing header
|
|
|
|
*
|
|
|
|
* @param String name Header name
|
|
|
|
* @param String value Header value
|
|
|
|
* @return Void
|
|
|
|
*/
|
|
|
|
append(name, value) {
|
|
|
|
if (!this.has(name)) {
|
|
|
|
this.set(name, value);
|
|
|
|
return;
|
2015-01-27 05:11:26 -08:00
|
|
|
}
|
2016-10-08 20:51:01 -07:00
|
|
|
|
2016-10-10 15:32:56 -07:00
|
|
|
this[MAP][sanitizeName(name)].push(sanitizeValue(value));
|
2015-01-27 05:11:26 -08:00
|
|
|
}
|
|
|
|
|
2016-10-08 20:51:01 -07:00
|
|
|
/**
|
|
|
|
* Check for header name existence
|
|
|
|
*
|
|
|
|
* @param String name Header name
|
|
|
|
* @return Boolean
|
|
|
|
*/
|
|
|
|
has(name) {
|
2016-10-15 10:02:52 -07:00
|
|
|
return !!this[MAP][sanitizeName(name)];
|
2016-10-08 20:51:01 -07:00
|
|
|
}
|
2015-01-27 05:11:26 -08:00
|
|
|
|
2016-10-08 20:51:01 -07:00
|
|
|
/**
|
|
|
|
* Delete all header values given name
|
|
|
|
*
|
|
|
|
* @param String name Header name
|
|
|
|
* @return Void
|
|
|
|
*/
|
|
|
|
delete(name) {
|
2016-10-10 15:32:56 -07:00
|
|
|
delete this[MAP][sanitizeName(name)];
|
2016-10-08 20:51:01 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return raw headers (non-spec api)
|
|
|
|
*
|
|
|
|
* @return Object
|
|
|
|
*/
|
|
|
|
raw() {
|
|
|
|
return this[MAP];
|
|
|
|
}
|
2015-01-27 05:11:26 -08:00
|
|
|
|
2016-10-08 20:51:01 -07:00
|
|
|
/**
|
|
|
|
* Get an iterator on keys.
|
|
|
|
*
|
|
|
|
* @return Iterator
|
|
|
|
*/
|
|
|
|
keys() {
|
2016-11-23 15:06:30 -08:00
|
|
|
return createHeadersIterator(this, 'key');
|
2015-01-27 05:11:26 -08:00
|
|
|
}
|
|
|
|
|
2016-10-08 20:51:01 -07:00
|
|
|
/**
|
|
|
|
* Get an iterator on values.
|
|
|
|
*
|
|
|
|
* @return Iterator
|
|
|
|
*/
|
2016-11-23 15:06:30 -08:00
|
|
|
values() {
|
|
|
|
return createHeadersIterator(this, 'value');
|
2016-10-08 20:51:01 -07:00
|
|
|
}
|
2015-10-26 22:13:02 -07:00
|
|
|
|
2016-10-08 20:51:01 -07:00
|
|
|
/**
|
|
|
|
* Get an iterator on entries.
|
|
|
|
*
|
|
|
|
* This is the default iterator of the Headers object.
|
|
|
|
*
|
|
|
|
* @return Iterator
|
|
|
|
*/
|
|
|
|
[Symbol.iterator]() {
|
2016-11-23 15:06:30 -08:00
|
|
|
return createHeadersIterator(this, 'key+value');
|
2016-10-08 20:51:01 -07:00
|
|
|
}
|
|
|
|
}
|
2016-11-23 15:06:30 -08:00
|
|
|
Headers.prototype.entries = Headers.prototype[Symbol.iterator];
|
2015-01-27 05:11:26 -08:00
|
|
|
|
2016-11-23 14:36:08 -08:00
|
|
|
Object.defineProperty(Headers.prototype, Symbol.toStringTag, {
|
|
|
|
value: 'HeadersPrototype',
|
|
|
|
writable: false,
|
|
|
|
enumerable: false,
|
|
|
|
configurable: true
|
|
|
|
});
|
|
|
|
|
2016-11-23 15:06:30 -08:00
|
|
|
function getHeaderPairs(headers, kind) {
|
|
|
|
if (headers[FOLLOW_SPEC]) {
|
|
|
|
const keys = Object.keys(headers[MAP]).sort();
|
|
|
|
return keys.map(
|
|
|
|
kind === 'key' ?
|
|
|
|
k => [k] :
|
|
|
|
k => [k, headers.get(k)]
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
const values = [];
|
|
|
|
|
|
|
|
for (let name in headers[MAP]) {
|
|
|
|
for (let value of headers[MAP][name]) {
|
|
|
|
values.push([name, value]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return values;
|
|
|
|
}
|
|
|
|
|
|
|
|
const INTERNAL = Symbol('internal');
|
|
|
|
|
|
|
|
function createHeadersIterator(target, kind) {
|
|
|
|
const iterator = Object.create(HeadersIteratorPrototype);
|
|
|
|
iterator[INTERNAL] = {
|
|
|
|
target,
|
|
|
|
kind,
|
|
|
|
index: 0
|
|
|
|
};
|
|
|
|
return iterator;
|
|
|
|
}
|
|
|
|
|
|
|
|
const HeadersIteratorPrototype = Object.setPrototypeOf({
|
|
|
|
next() {
|
|
|
|
if (!this ||
|
|
|
|
Object.getPrototypeOf(this) !== HeadersIteratorPrototype) {
|
|
|
|
throw new TypeError('Value of `this` is not a HeadersIterator');
|
|
|
|
}
|
|
|
|
|
|
|
|
const {
|
|
|
|
target,
|
|
|
|
kind,
|
|
|
|
index
|
|
|
|
} = this[INTERNAL];
|
|
|
|
const values = getHeaderPairs(target, kind);
|
|
|
|
const len = values.length;
|
|
|
|
if (index >= len) {
|
|
|
|
return {
|
|
|
|
value: undefined,
|
|
|
|
done: true
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
const pair = values[index];
|
|
|
|
this[INTERNAL].index = index + 1;
|
|
|
|
|
|
|
|
let result;
|
|
|
|
if (kind === 'key') {
|
|
|
|
result = pair[0];
|
|
|
|
} else if (kind === 'value') {
|
|
|
|
result = pair[1];
|
|
|
|
} else {
|
|
|
|
result = pair;
|
|
|
|
}
|
|
|
|
|
|
|
|
return {
|
|
|
|
value: result,
|
|
|
|
done: false
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}, Object.getPrototypeOf(
|
|
|
|
Object.getPrototypeOf([][Symbol.iterator]())
|
|
|
|
));
|
|
|
|
|
|
|
|
Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, {
|
|
|
|
value: 'HeadersIterator',
|
|
|
|
writable: false,
|
|
|
|
enumerable: false,
|
|
|
|
configurable: true
|
|
|
|
});
|
|
|
|
|
2016-10-10 18:31:53 -07:00
|
|
|
Headers.FOLLOW_SPEC = false;
|