rekwest 5.0.2 → 5.0.3

package/src/preflight.mjs

@@ -1,87 +1,87 @@
-import http2 from 'node:http2';
-import { requestCredentials } from './constants.mjs';
-import { Cookies } from './cookies.mjs';
-import {
-  APPLICATION_JSON,
-  TEXT_PLAIN,
-  WILDCARD,
-} from './mediatypes.mjs';
-
-const {
-  HTTP2_HEADER_ACCEPT,
-  HTTP2_HEADER_ACCEPT_ENCODING,
-  HTTP2_HEADER_AUTHORITY,
-  HTTP2_HEADER_AUTHORIZATION,
-  HTTP2_HEADER_COOKIE,
-  HTTP2_HEADER_METHOD,
-  HTTP2_HEADER_PATH,
-  HTTP2_HEADER_SCHEME,
-  HTTP2_METHOD_GET,
-  HTTP2_METHOD_HEAD,
-} = http2.constants;
-
-export const preflight = (options) => {
-  const { cookies, credentials, h2, headers, method, url } = options;
-
-  if (h2) {
-    options.endStream = [
-      HTTP2_METHOD_GET,
-      HTTP2_METHOD_HEAD,
-    ].includes(method);
-  }
-
-  if (cookies !== false && credentials !== requestCredentials.omit) {
-    let cookie = Cookies.jar.has(url.origin);
-
-    if (cookies === Object(cookies) && [
-      requestCredentials.include,
-      requestCredentials.sameOrigin,
-    ].includes(credentials)) {
-      if (cookie) {
-        cookie = new Cookies(cookies, options);
-
-        Cookies.jar.get(url.origin).forEach((val, key) => {
-          if (!cookie.has(key)) {
-            cookie.set(key, val);
-          }
-        });
-        Cookies.jar.set(url.origin, cookie);
-      } else {
-        cookie = new Cookies(cookies, options);
-        Cookies.jar.set(url.origin, cookie);
-      }
-    } else {
-      cookie &&= Cookies.jar.get(url.origin);
-    }
-
-    options.headers = {
-      ...cookie && { [HTTP2_HEADER_COOKIE]: cookie },
-      ...headers,
-    };
-  }
-
-  if (credentials === requestCredentials.omit) {
-    options.cookies = false;
-    Object.keys(options.headers ?? {})
-          .filter((it) => new RegExp(`^(${
-            HTTP2_HEADER_AUTHORIZATION }|${ HTTP2_HEADER_COOKIE
-          })$`, 'i').test(it))
-          .forEach((it) => Reflect.deleteProperty(options.headers, it));
-    url.password = url.username = '';
-  }
-
-  options.headers = {
-    [HTTP2_HEADER_ACCEPT]: `${ APPLICATION_JSON }, ${ TEXT_PLAIN }, ${ WILDCARD }`,
-    [HTTP2_HEADER_ACCEPT_ENCODING]: 'br, deflate, deflate-raw, gzip, identity',
-    ...Object.entries(options.headers ?? {})
-             .reduce((acc, [key, val]) => (acc[key.toLowerCase()] = val, acc), {}),
-    ...h2 && {
-      [HTTP2_HEADER_AUTHORITY]: url.host,
-      [HTTP2_HEADER_METHOD]: method,
-      [HTTP2_HEADER_PATH]: `${ url.pathname }${ url.search }`,
-      [HTTP2_HEADER_SCHEME]: url.protocol.replace(/\p{Punctuation}/gu, ''),
-    },
-  };
-
-  return options;
-};
+import http2 from 'node:http2';
+import { requestCredentials } from './constants.mjs';
+import { Cookies } from './cookies.mjs';
+import {
+  APPLICATION_JSON,
+  TEXT_PLAIN,
+  WILDCARD,
+} from './mediatypes.mjs';
+
+const {
+  HTTP2_HEADER_ACCEPT,
+  HTTP2_HEADER_ACCEPT_ENCODING,
+  HTTP2_HEADER_AUTHORITY,
+  HTTP2_HEADER_AUTHORIZATION,
+  HTTP2_HEADER_COOKIE,
+  HTTP2_HEADER_METHOD,
+  HTTP2_HEADER_PATH,
+  HTTP2_HEADER_SCHEME,
+  HTTP2_METHOD_GET,
+  HTTP2_METHOD_HEAD,
+} = http2.constants;
+
+export const preflight = (options) => {
+  const { cookies, credentials, h2, headers, method, url } = options;
+
+  if (h2) {
+    options.endStream = [
+      HTTP2_METHOD_GET,
+      HTTP2_METHOD_HEAD,
+    ].includes(method);
+  }
+
+  if (cookies !== false && credentials !== requestCredentials.omit) {
+    let cookie = Cookies.jar.has(url.origin);
+
+    if (cookies === Object(cookies) && [
+      requestCredentials.include,
+      requestCredentials.sameOrigin,
+    ].includes(credentials)) {
+      if (cookie) {
+        cookie = new Cookies(cookies, options);
+
+        Cookies.jar.get(url.origin).forEach((val, key) => {
+          if (!cookie.has(key)) {
+            cookie.set(key, val);
+          }
+        });
+        Cookies.jar.set(url.origin, cookie);
+      } else {
+        cookie = new Cookies(cookies, options);
+        Cookies.jar.set(url.origin, cookie);
+      }
+    } else {
+      cookie &&= Cookies.jar.get(url.origin);
+    }
+
+    options.headers = {
+      ...cookie && { [HTTP2_HEADER_COOKIE]: cookie },
+      ...headers,
+    };
+  }
+
+  if (credentials === requestCredentials.omit) {
+    options.cookies = false;
+    for (const it of Object.keys(options.headers ?? {})
+                           .filter((val) => new RegExp(`^(${
+                              HTTP2_HEADER_AUTHORIZATION }|${ HTTP2_HEADER_COOKIE
+                            })$`, 'i').test(val))) { Reflect.deleteProperty(options.headers, it); }
+
+    url.password = url.username = '';
+  }
+
+  options.headers = {
+    [HTTP2_HEADER_ACCEPT]: `${ APPLICATION_JSON }, ${ TEXT_PLAIN }, ${ WILDCARD }`,
+    [HTTP2_HEADER_ACCEPT_ENCODING]: 'br, deflate, deflate-raw, gzip, identity',
+    ...Object.entries(options.headers ?? {})
+             .reduce((acc, [key, val]) => (acc[key.toLowerCase()] = val, acc), {}),
+    ...h2 && {
+      [HTTP2_HEADER_AUTHORITY]: url.host,
+      [HTTP2_HEADER_METHOD]: method,
+      [HTTP2_HEADER_PATH]: `${ url.pathname }${ url.search }`,
+      [HTTP2_HEADER_SCHEME]: url.protocol.replace(/\p{Punctuation}/gu, ''),
+    },
+  };
+
+  return options;
+};

package/src/transfer.mjs

@@ -1,114 +1,114 @@
-import http from 'node:http';
-import http2 from 'node:http2';
-import https from 'node:https';
-import { setTimeout as setTimeoutPromise } from 'node:timers/promises';
-import { ackn } from './ackn.mjs';
-import { RequestError } from './errors.mjs';
-import { postflight } from './postflight.mjs';
-import { preflight } from './preflight.mjs';
-import { transform } from './transform.mjs';
-import {
-  affix,
-  dispatch,
-  maxRetryAfterError,
-} from './utils.mjs';
-
-const {
-  HTTP2_HEADER_RETRY_AFTER,
-} = http2.constants;
-
-export const transfer = async (options, overact) => {
-  const { digest, redirected, thenable, url } = options;
-
-  if (options.follow === 0) {
-    throw new RequestError(`Maximum redirect reached at: ${ url.href }`);
-  }
-
-  if (url.protocol === 'https:') {
-    options = !options.h2 ? await ackn(options) : {
-      ...options,
-      createConnection: null,
-      protocol: url.protocol,
-    };
-  } else if (Reflect.has(options, 'alpnProtocol')) {
-    [
-      'alpnProtocol',
-      'createConnection',
-      'h2',
-      'protocol',
-    ].forEach((it) => Reflect.deleteProperty(options, it));
-  }
-
-  try {
-    options = await transform(preflight(options));
-  } catch (ex) {
-    options.createConnection?.().destroy();
-    throw ex;
-  }
-
-  const promise = new Promise((resolve, reject) => {
-    let client, req;
-
-    if (options.h2) {
-      client = http2.connect(url.origin, options);
-      req = client.request(options.headers, options);
-    } else {
-      const { request } = url.protocol === 'http:' ? http : https;
-
-      req = request(url, options);
-    }
-
-    affix(client, req, options);
-
-    req.once('error', reject);
-    req.once('frameError', reject);
-    req.once('goaway', reject);
-    req.once('response', (res) => postflight(req, res, options, {
-      reject,
-      resolve,
-    }));
-
-    dispatch(options, req);
-  });
-
-  try {
-    const res = await promise;
-
-    if (digest && !redirected) {
-      res.body = await res.body();
-    }
-
-    return res;
-  } catch (ex) {
-    const { maxRetryAfter, retry } = options;
-
-    if (retry?.attempts && retry?.statusCodes.includes(ex.statusCode)) {
-      let { interval } = retry;
-
-      if (retry.retryAfter && ex.headers[HTTP2_HEADER_RETRY_AFTER]) {
-        interval = ex.headers[HTTP2_HEADER_RETRY_AFTER];
-        interval = Number(interval) * 1000 || new Date(interval) - Date.now();
-        if (interval > maxRetryAfter) {
-          throw maxRetryAfterError(interval, { cause: ex });
-        }
-      } else {
-        interval = new Function('interval', `return Math.ceil(${ retry.backoffStrategy });`)(interval);
-      }
-
-      retry.attempts--;
-      retry.interval = interval;
-
-      return setTimeoutPromise(interval).then(() => overact(url, options));
-    }
-
-    if (digest && !redirected && ex.body) {
-      ex.body = await ex.body();
-    }
-
-    if (!thenable) {
-      throw ex;
-    } else {
-      return ex;
-    }
-  }
-};
+import http from 'node:http';
+import http2 from 'node:http2';
+import https from 'node:https';
+import { setTimeout as setTimeoutPromise } from 'node:timers/promises';
+import { ackn } from './ackn.mjs';
+import { RequestError } from './errors.mjs';
+import { postflight } from './postflight.mjs';
+import { preflight } from './preflight.mjs';
+import { transform } from './transform.mjs';
+import {
+  affix,
+  dispatch,
+  maxRetryAfterError,
+} from './utils.mjs';
+
+const {
+  HTTP2_HEADER_RETRY_AFTER,
+} = http2.constants;
+
+export const transfer = async (options, overact) => {
+  const { digest, redirected, thenable, url } = options;
+
+  if (options.follow === 0) {
+    throw new RequestError(`Maximum redirect reached at: ${ url.href }`);
+  }
+
+  if (url.protocol === 'https:') {
+    options = !options.h2 ? await ackn(options) : {
+      ...options,
+      createConnection: null,
+      protocol: url.protocol,
+    };
+  } else if (Reflect.has(options, 'alpnProtocol')) {
+    for (const it of [
+      'alpnProtocol',
+      'createConnection',
+      'h2',
+      'protocol',
+    ]) { Reflect.deleteProperty(options, it); }
+  }
+
+  try {
+    options = await transform(preflight(options));
+  } catch (ex) {
+    options.createConnection?.().destroy();
+    throw ex;
+  }
+
+  const promise = new Promise((resolve, reject) => {
+    let client, req;
+
+    if (options.h2) {
+      client = http2.connect(url.origin, options);
+      req = client.request(options.headers, options);
+    } else {
+      const { request } = url.protocol === 'http:' ? http : https;
+
+      req = request(url, options);
+    }
+
+    affix(client, req, options);
+
+    req.once('error', reject);
+    req.once('frameError', reject);
+    req.once('goaway', reject);
+    req.once('response', (res) => postflight(req, res, options, {
+      reject,
+      resolve,
+    }));
+
+    dispatch(options, req);
+  });
+
+  try {
+    const res = await promise;
+
+    if (digest && !redirected) {
+      res.body = await res.body();
+    }
+
+    return res;
+  } catch (ex) {
+    const { maxRetryAfter, retry } = options;
+
+    if (retry?.attempts && retry?.statusCodes.includes(ex.statusCode)) {
+      let { interval } = retry;
+
+      if (retry.retryAfter && ex.headers[HTTP2_HEADER_RETRY_AFTER]) {
+        interval = ex.headers[HTTP2_HEADER_RETRY_AFTER];
+        interval = Number(interval) * 1000 || new Date(interval) - Date.now();
+        if (interval > maxRetryAfter) {
+          throw maxRetryAfterError(interval, { cause: ex });
+        }
+      } else {
+        interval = new Function('interval', `return Math.ceil(${ retry.backoffStrategy });`)(interval);
+      }
+
+      retry.attempts--;
+      retry.interval = interval;
+
+      return setTimeoutPromise(interval).then(() => overact(url, options));
+    }
+
+    if (digest && !redirected && ex.body) {
+      ex.body = await ex.body();
+    }
+
+    if (!thenable) {
+      throw ex;
+    } else {
+      return ex;
+    }
+  }
+};