rekwest/dist/utils.cjs

The robust request library that humanity deserves 🌐

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.stripHeaders = exports.snoop = exports.sameOrigin = exports.normalizeHeaders = exports.normalize = exports.merge = exports.isReadableStream = exports.isPipeStream = exports.isFileLike = exports.dispatch = exports.copyWithMerge = exports.brandCheck = exports.augment = void 0;
exports.tap = tap;
exports.unwind = exports.toCamelCase = void 0;
var _nodeBuffer = require("node:buffer");
var _nodeHttp = _interopRequireDefault(require("node:http2"));
var _nodeStream = require("node:stream");
var _config = _interopRequireWildcard(require("./config.cjs"));
var _errors = require("./errors.cjs");
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const {
  HTTP2_HEADER_ACCEPT_ENCODING,
  HTTP2_HEADER_STATUS
} = _nodeHttp.default.constants;
const augment = (res, headers, options) => {
  const {
    h2
  } = options;
  if (h2) {
    Reflect.defineProperty(res, 'headers', {
      enumerable: true,
      value: headers
    });
    Reflect.defineProperty(res, 'httpVersion', {
      enumerable: true,
      value: `${h2 + 1}.0`
    });
    Reflect.defineProperty(res, 'statusCode', {
      enumerable: true,
      value: headers[HTTP2_HEADER_STATUS]
    });
  }
  Reflect.defineProperty(res, 'ok', {
    enumerable: true,
    value: /^2\d{2}$/.test(res.statusCode)
  });
  Reflect.defineProperty(res, 'redirected', {
    enumerable: true,
    value: !!options.redirected
  });
};
exports.augment = augment;
const brandCheck = (value, ctor) => {
  if (!(value instanceof ctor)) {
    throw new TypeError('Illegal invocation.');
  }
};
exports.brandCheck = brandCheck;
const copyWithMerge = (target, ...rest) => {
  target = structuredClone(target);
  if (!rest.length) {
    return target;
  }
  return merge(target, ...rest);
};
exports.copyWithMerge = copyWithMerge;
const dispatch = (req, {
  body
}) => {
  if ((0, _nodeStream.isReadable)(body)) {
    body.pipe(req);
  } else {
    req.end(body);
  }
};
exports.dispatch = dispatch;
const isFileLike = value => {
  return [_nodeBuffer.Blob, _nodeBuffer.File].some(it => value instanceof it);
};
exports.isFileLike = isFileLike;
const isPipeStream = value => {
  return value instanceof _nodeStream.Readable;
};
exports.isPipeStream = isPipeStream;
const isReadableStream = value => {
  return value instanceof ReadableStream;
};
exports.isReadableStream = isReadableStream;
const merge = (target, ...rest) => {
  rest = rest.filter(it => Object(it) === it);
  for (const source of rest) {
    for (const key of Object.getOwnPropertyNames(source)) {
      const sv = source[key];
      const tv = target[key];
      if (Object(sv) === sv && Object(tv) === tv) {
        target[key] = merge(tv, sv);
        continue;
      }
      target[key] = source[key];
    }
  }
  return target;
};
exports.merge = merge;
const normalize = (url, options = {}) => {
  if (!options.redirected) {
    options = copyWithMerge(_config.default.defaults, options);
  }
  if (options.trimTrailingSlashes) {
    url = `${url}`.replace(/(?<!:)\/+/g, '/');
  }
  if (options.stripTrailingSlash) {
    url = `${url}`.replace(/\/$|\/(?=#)|\/(?=\?)/g, '');
  }
  return Object.assign(options, {
    headers: normalizeHeaders(options.headers),
    method: options.method.toUpperCase(),
    url: new URL(url, options.baseURL)
  });
};
exports.normalize = normalize;
const normalizeHeaders = headers => {
  const collector = {};
  for (const [key, value] of Object.entries(headers ?? {})) {
    const name = key.toLowerCase();
    collector[key] = value;
    if (key === HTTP2_HEADER_ACCEPT_ENCODING && !_config.isZstdSupported) {
      const stripped = value.replace(/\s?zstd,?/gi, '').trim();
      if (stripped) {
        collector[key] = stripped;
      } else {
        Reflect.deleteProperty(collector, name);
      }
    }
  }
  return collector;
};
exports.normalizeHeaders = normalizeHeaders;
const sameOrigin = (a, b) => a.protocol === b.protocol && a.hostname === b.hostname && a.port === b.port;
exports.sameOrigin = sameOrigin;
const snoop = (client, req, options) => {
  req.once('close', () => client?.close());
  req.once('end', () => client?.close());
  req.once('timeout', () => req.destroy(new _errors.TimeoutError(`Timed out after ${options.timeout} ms.`)));
  req.once('trailers', trailers => {
    Reflect.defineProperty(req, 'trailers', {
      enumerable: true,
      value: trailers
    });
  });
};
exports.snoop = snoop;
const stripHeaders = (headers = {}, names = []) => {
  names = new Set(names);
  return Object.fromEntries(Object.entries(headers).filter(([key]) => !names.has(key.toLowerCase())));
};
exports.stripHeaders = stripHeaders;
async function* tap(value) {
  if (Reflect.has(value, Symbol.asyncIterator)) {
    yield* value;
  } else if (value.stream) {
    yield* value.stream();
  } else {
    yield await value.arrayBuffer();
  }
}
const toCamelCase = str => str?.toLowerCase().replace(/\p{Punctuation}.|\p{White_Space}./gu, val => val.replace(/\p{Punctuation}+|\p{White_Space}+/gu, '').toUpperCase());
exports.toCamelCase = toCamelCase;
const unwind = encodings => encodings.split(',').map(it => it.toLowerCase().trim());
exports.unwind = unwind;