opusdev/vector-similarity-api

1'use strict';2 3import utils from '../utils.js';4import parseHeaders from '../helpers/parseHeaders.js';5 6const $internals = Symbol('internals');7 8function normalizeHeader(header) {9  return header && String(header).trim().toLowerCase();10}11 12function normalizeValue(value) {13  if (value === false || value == null) {14    return value;15  }16 17  return utils.isArray(value) ? value.map(normalizeValue) : String(value);18}19 20function parseTokens(str) {21  const tokens = Object.create(null);22  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;23  let match;24 25  while ((match = tokensRE.exec(str))) {26    tokens[match[1]] = match[2];27  }28 29  return tokens;30}31 32const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());33 34function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {35  if (utils.isFunction(filter)) {36    return filter.call(this, value, header);37  }38 39  if (isHeaderNameFilter) {40    value = header;41  }42 43  if (!utils.isString(value)) return;44 45  if (utils.isString(filter)) {46    return value.indexOf(filter) !== -1;47  }48 49  if (utils.isRegExp(filter)) {50    return filter.test(value);51  }52}53 54function formatHeader(header) {55  return header.trim()56    .toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {57      return char.toUpperCase() + str;58    });59}60 61function buildAccessors(obj, header) {62  const accessorName = utils.toCamelCase(' ' + header);63 64  ['get', 'set', 'has'].forEach(methodName => {65    Object.defineProperty(obj, methodName + accessorName, {66      value: function(arg1, arg2, arg3) {67        return this[methodName].call(this, header, arg1, arg2, arg3);68      },69      configurable: true70    });71  });72}73 74class AxiosHeaders {75  constructor(headers) {76    headers && this.set(headers);77  }78 79  set(header, valueOrRewrite, rewrite) {80    const self = this;81 82    function setHeader(_value, _header, _rewrite) {83      const lHeader = normalizeHeader(_header);84 85      if (!lHeader) {86        throw new Error('header name must be a non-empty string');87      }88 89      const key = utils.findKey(self, lHeader);90 91      if(!key || self[key] === undefined || _rewrite === true || (_rewrite === undefined && self[key] !== false)) {92        self[key || _header] = normalizeValue(_value);93      }94    }95 96    const setHeaders = (headers, _rewrite) =>97      utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));98 99    if (utils.isPlainObject(header) || header instanceof this.constructor) {100      setHeaders(header, valueOrRewrite)101    } else if(utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {102      setHeaders(parseHeaders(header), valueOrRewrite);103    } else if (utils.isObject(header) && utils.isIterable(header)) {104      let obj = {}, dest, key;105      for (const entry of header) {106        if (!utils.isArray(entry)) {107          throw TypeError('Object iterator must return a key-value pair');108        }109 110        obj[key = entry[0]] = (dest = obj[key]) ?111          (utils.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]]) : entry[1];112      }113 114      setHeaders(obj, valueOrRewrite)115    } else {116      header != null && setHeader(valueOrRewrite, header, rewrite);117    }118 119    return this;120  }121 122  get(header, parser) {123    header = normalizeHeader(header);124 125    if (header) {126      const key = utils.findKey(this, header);127 128      if (key) {129        const value = this[key];130 131        if (!parser) {132          return value;133        }134 135        if (parser === true) {136          return parseTokens(value);137        }138 139        if (utils.isFunction(parser)) {140          return parser.call(this, value, key);141        }142 143        if (utils.isRegExp(parser)) {144          return parser.exec(value);145        }146 147        throw new TypeError('parser must be boolean|regexp|function');148      }149    }150  }151 152  has(header, matcher) {153    header = normalizeHeader(header);154 155    if (header) {156      const key = utils.findKey(this, header);157 158      return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));159    }160 161    return false;162  }163 164  delete(header, matcher) {165    const self = this;166    let deleted = false;167 168    function deleteHeader(_header) {169      _header = normalizeHeader(_header);170 171      if (_header) {172        const key = utils.findKey(self, _header);173 174        if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {175          delete self[key];176 177          deleted = true;178        }179      }180    }181 182    if (utils.isArray(header)) {183      header.forEach(deleteHeader);184    } else {185      deleteHeader(header);186    }187 188    return deleted;189  }190 191  clear(matcher) {192    const keys = Object.keys(this);193    let i = keys.length;194    let deleted = false;195 196    while (i--) {197      const key = keys[i];198      if(!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {199        delete this[key];200        deleted = true;201      }202    }203 204    return deleted;205  }206 207  normalize(format) {208    const self = this;209    const headers = {};210 211    utils.forEach(this, (value, header) => {212      const key = utils.findKey(headers, header);213 214      if (key) {215        self[key] = normalizeValue(value);216        delete self[header];217        return;218      }219 220      const normalized = format ? formatHeader(header) : String(header).trim();221 222      if (normalized !== header) {223        delete self[header];224      }225 226      self[normalized] = normalizeValue(value);227 228      headers[normalized] = true;229    });230 231    return this;232  }233 234  concat(...targets) {235    return this.constructor.concat(this, ...targets);236  }237 238  toJSON(asStrings) {239    const obj = Object.create(null);240 241    utils.forEach(this, (value, header) => {242      value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value);243    });244 245    return obj;246  }247 248  [Symbol.iterator]() {249    return Object.entries(this.toJSON())[Symbol.iterator]();250  }251 252  toString() {253    return Object.entries(this.toJSON()).map(([header, value]) => header + ': ' + value).join('\n');254  }255 256  getSetCookie() {257    return this.get("set-cookie") || [];258  }259 260  get [Symbol.toStringTag]() {261    return 'AxiosHeaders';262  }263 264  static from(thing) {265    return thing instanceof this ? thing : new this(thing);266  }267 268  static concat(first, ...targets) {269    const computed = new this(first);270 271    targets.forEach((target) => computed.set(target));272 273    return computed;274  }275 276  static accessor(header) {277    const internals = this[$internals] = (this[$internals] = {278      accessors: {}279    });280 281    const accessors = internals.accessors;282    const prototype = this.prototype;283 284    function defineAccessor(_header) {285      const lHeader = normalizeHeader(_header);286 287      if (!accessors[lHeader]) {288        buildAccessors(prototype, _header);289        accessors[lHeader] = true;290      }291    }292 293    utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);294 295    return this;296  }297}298 299AxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);300 301// reserved names hotfix302utils.reduceDescriptors(AxiosHeaders.prototype, ({value}, key) => {303  let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`304  return {305    get: () => value,306    set(headerValue) {307      this[mapped] = headerValue;308    }309  }310});311 312utils.freezeMethods(AxiosHeaders);313 314export default AxiosHeaders;315