AxiosHeaders.js 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290
  1. 'use strict';
  2. import utils from '../utils.js';
  3. import parseHeaders from '../helpers/parseHeaders.js';
  4. const $internals = Symbol('internals');
  5. function normalizeHeader(header) {
  6. return header && String(header).trim().toLowerCase();
  7. }
  8. function normalizeValue(value) {
  9. if (value === false || value == null) {
  10. return value;
  11. }
  12. return utils.isArray(value) ? value.map(normalizeValue) : String(value);
  13. }
  14. function parseTokens(str) {
  15. const tokens = Object.create(null);
  16. const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
  17. let match;
  18. while ((match = tokensRE.exec(str))) {
  19. tokens[match[1]] = match[2];
  20. }
  21. return tokens;
  22. }
  23. function isValidHeaderName(str) {
  24. return /^[-_a-zA-Z]+$/.test(str.trim());
  25. }
  26. function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
  27. if (utils.isFunction(filter)) {
  28. return filter.call(this, value, header);
  29. }
  30. if (isHeaderNameFilter) {
  31. value = header;
  32. }
  33. if (!utils.isString(value)) return;
  34. if (utils.isString(filter)) {
  35. return value.indexOf(filter) !== -1;
  36. }
  37. if (utils.isRegExp(filter)) {
  38. return filter.test(value);
  39. }
  40. }
  41. function formatHeader(header) {
  42. return header.trim()
  43. .toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
  44. return char.toUpperCase() + str;
  45. });
  46. }
  47. function buildAccessors(obj, header) {
  48. const accessorName = utils.toCamelCase(' ' + header);
  49. ['get', 'set', 'has'].forEach(methodName => {
  50. Object.defineProperty(obj, methodName + accessorName, {
  51. value: function(arg1, arg2, arg3) {
  52. return this[methodName].call(this, header, arg1, arg2, arg3);
  53. },
  54. configurable: true
  55. });
  56. });
  57. }
  58. class AxiosHeaders {
  59. constructor(headers) {
  60. headers && this.set(headers);
  61. }
  62. set(header, valueOrRewrite, rewrite) {
  63. const self = this;
  64. function setHeader(_value, _header, _rewrite) {
  65. const lHeader = normalizeHeader(_header);
  66. if (!lHeader) {
  67. throw new Error('header name must be a non-empty string');
  68. }
  69. const key = utils.findKey(self, lHeader);
  70. if(!key || self[key] === undefined || _rewrite === true || (_rewrite === undefined && self[key] !== false)) {
  71. self[key || _header] = normalizeValue(_value);
  72. }
  73. }
  74. const setHeaders = (headers, _rewrite) =>
  75. utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
  76. if (utils.isPlainObject(header) || header instanceof this.constructor) {
  77. setHeaders(header, valueOrRewrite)
  78. } else if(utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
  79. setHeaders(parseHeaders(header), valueOrRewrite);
  80. } else {
  81. header != null && setHeader(valueOrRewrite, header, rewrite);
  82. }
  83. return this;
  84. }
  85. get(header, parser) {
  86. header = normalizeHeader(header);
  87. if (header) {
  88. const key = utils.findKey(this, header);
  89. if (key) {
  90. const value = this[key];
  91. if (!parser) {
  92. return value;
  93. }
  94. if (parser === true) {
  95. return parseTokens(value);
  96. }
  97. if (utils.isFunction(parser)) {
  98. return parser.call(this, value, key);
  99. }
  100. if (utils.isRegExp(parser)) {
  101. return parser.exec(value);
  102. }
  103. throw new TypeError('parser must be boolean|regexp|function');
  104. }
  105. }
  106. }
  107. has(header, matcher) {
  108. header = normalizeHeader(header);
  109. if (header) {
  110. const key = utils.findKey(this, header);
  111. return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
  112. }
  113. return false;
  114. }
  115. delete(header, matcher) {
  116. const self = this;
  117. let deleted = false;
  118. function deleteHeader(_header) {
  119. _header = normalizeHeader(_header);
  120. if (_header) {
  121. const key = utils.findKey(self, _header);
  122. if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {
  123. delete self[key];
  124. deleted = true;
  125. }
  126. }
  127. }
  128. if (utils.isArray(header)) {
  129. header.forEach(deleteHeader);
  130. } else {
  131. deleteHeader(header);
  132. }
  133. return deleted;
  134. }
  135. clear(matcher) {
  136. const keys = Object.keys(this);
  137. let i = keys.length;
  138. let deleted = false;
  139. while (i--) {
  140. const key = keys[i];
  141. if(!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
  142. delete this[key];
  143. deleted = true;
  144. }
  145. }
  146. return deleted;
  147. }
  148. normalize(format) {
  149. const self = this;
  150. const headers = {};
  151. utils.forEach(this, (value, header) => {
  152. const key = utils.findKey(headers, header);
  153. if (key) {
  154. self[key] = normalizeValue(value);
  155. delete self[header];
  156. return;
  157. }
  158. const normalized = format ? formatHeader(header) : String(header).trim();
  159. if (normalized !== header) {
  160. delete self[header];
  161. }
  162. self[normalized] = normalizeValue(value);
  163. headers[normalized] = true;
  164. });
  165. return this;
  166. }
  167. concat(...targets) {
  168. return this.constructor.concat(this, ...targets);
  169. }
  170. toJSON(asStrings) {
  171. const obj = Object.create(null);
  172. utils.forEach(this, (value, header) => {
  173. value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value);
  174. });
  175. return obj;
  176. }
  177. [Symbol.iterator]() {
  178. return Object.entries(this.toJSON())[Symbol.iterator]();
  179. }
  180. toString() {
  181. return Object.entries(this.toJSON()).map(([header, value]) => header + ': ' + value).join('\n');
  182. }
  183. get [Symbol.toStringTag]() {
  184. return 'AxiosHeaders';
  185. }
  186. static from(thing) {
  187. return thing instanceof this ? thing : new this(thing);
  188. }
  189. static concat(first, ...targets) {
  190. const computed = new this(first);
  191. targets.forEach((target) => computed.set(target));
  192. return computed;
  193. }
  194. static accessor(header) {
  195. const internals = this[$internals] = (this[$internals] = {
  196. accessors: {}
  197. });
  198. const accessors = internals.accessors;
  199. const prototype = this.prototype;
  200. function defineAccessor(_header) {
  201. const lHeader = normalizeHeader(_header);
  202. if (!accessors[lHeader]) {
  203. buildAccessors(prototype, _header);
  204. accessors[lHeader] = true;
  205. }
  206. }
  207. utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
  208. return this;
  209. }
  210. }
  211. AxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);
  212. utils.freezeMethods(AxiosHeaders.prototype);
  213. utils.freezeMethods(AxiosHeaders);
  214. export default AxiosHeaders;