rekwest 3.1.0 → 3.3.0

package/src/formdata.mjs

@@ -1,224 +1,239 @@
-import { randomBytes } from 'crypto';
-import http2 from 'http2';
-import { toUSVString } from 'util';
-import { File } from './file.mjs';
-import { tap } from './helpers.mjs';
-import {
-  APPLICATION_OCTET_STREAM,
-  MULTIPART_FORM_DATA,
-} from './mediatypes.mjs';
-
-const CRLF = '\r\n';
-const {
-  HTTP2_HEADER_CONTENT_DISPOSITION,
-  HTTP2_HEADER_CONTENT_TYPE,
-} = http2.constants;
-
-export class FormData {
-
-  static actuate(fd) {
-    const boundary = randomBytes(24).toString('hex');
-    const contentType = `${ MULTIPART_FORM_DATA }; boundary=${ boundary }`;
-    const prefix = `--${ boundary }${ CRLF }${ HTTP2_HEADER_CONTENT_DISPOSITION }: form-data`;
-
-    const escape = (str) => str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22');
-    const normalize = (value) => value.replace(/\r?\n|\r/g, CRLF);
-
-    return {
-      contentType,
-      async* [Symbol.asyncIterator]() {
-        const encoder = new TextEncoder();
-
-        for (const [name, value] of fd) {
-          if (value.constructor === String) {
-            yield encoder.encode(`${ prefix }; name="${
-              escape(normalize(name))
-            }"${ CRLF.repeat(2) }${ normalize(value) }${ CRLF }`);
-          } else {
-            yield encoder.encode(`${ prefix }; name="${
-              escape(normalize(name))
-            }"${ value.name ? `; filename="${ escape(value.name) }"` : '' }${ CRLF }${
-              HTTP2_HEADER_CONTENT_TYPE
-            }: ${
-              value.type || APPLICATION_OCTET_STREAM
-            }${ CRLF.repeat(2) }`);
-            yield* tap(value);
-            yield encoder.encode(CRLF);
-          }
-        }
-
-        yield encoder.encode(`--${ boundary }--`);
-      },
-    };
-  }
-
-  static alike(instance) {
-    return instance?.constructor.name === FormData.name;
-  }
-
-  static #enfoldEntry(name, value, filename) {
-    name = toUSVString(name);
-    filename &&= toUSVString(filename);
-
-    if (File.alike(value)) {
-      value = new File([value], filename, value);
-    } else if (this.#ensureInstance(value)) {
-      value.name = filename || value.name;
-    } else {
-      value = toUSVString(value);
-    }
-
-    return {
-      name,
-      value,
-    };
-  }
-
-  static #ensureInstance(value) {
-    return File.alike(value) || (value === Object(value) && Reflect.has(value, Symbol.asyncIterator));
-  }
-
-  #entries = [];
-
-  get [Symbol.toStringTag]() {
-    return this.constructor.name;
-  }
-
-  constructor(input) {
-    if (input === Object(input)
-      && (input?.constructor === Object || Reflect.has(input, Symbol.iterator))) {
-
-      if (input.constructor !== Object) {
-        input = Array.from(input);
-      }
-
-      if (Array.isArray(input)) {
-        if (!input.every((it) => Array.isArray(it))) {
-          throw new TypeError(`Failed to construct '${
-            this[Symbol.toStringTag]
-          }': The provided value cannot be converted to a sequence.`);
-        } else if (!input.every((it) => it.length === 2)) {
-          throw new TypeError(`Failed to construct '${
-            this[Symbol.toStringTag]
-          }': Sequence initializer must only contain pair elements.`);
-        }
-      }
-
-      if (input.constructor === Object) {
-        input = Object.entries(input);
-      }
-
-      input.forEach(([key, value]) => this.append(key, value));
-    }
-  }
-
-  #ensureArgs(args, expected, method) {
-    if (args.length < expected) {
-      throw new TypeError(`Failed to execute '${ method }' on '${
-        this[Symbol.toStringTag]
-      }': ${ expected } arguments required, but only ${ args.length } present.`);
-    }
-
-    if ([
-      'append',
-      'set',
-    ].includes(method)) {
-      if (args.length === 3 && !this.constructor.#ensureInstance(args[1])) {
-        throw new TypeError(`Failed to execute '${ method }' on '${
-          this[Symbol.toStringTag]
-        }': parameter ${ expected } is not of type 'Blob', 'File' or async iterable.`);
-      }
-    }
-
-    if (method === 'forEach') {
-      if (args[0]?.constructor !== Function) {
-        throw new TypeError(`Failed to execute '${ method }' on '${
-          this[Symbol.toStringTag]
-        }': parameter ${ expected } is not of type 'Function'.`);
-      }
-    }
-  }
-
-  append(...args) {
-    this.#ensureArgs(args, 2, 'append');
-    this.#entries.push(this.constructor.#enfoldEntry(...args));
-  }
-
-  delete(...args) {
-    this.#ensureArgs(args, 1, 'delete');
-    const name = toUSVString(args[0]);
-
-    this.#entries = this.#entries.filter((it) => it.name !== name);
-  }
-
-  forEach(...args) {
-    this.#ensureArgs(args, 1, 'forEach');
-    const [callback, thisArg] = args;
-
-    for (const entry of this) {
-      Reflect.apply(callback, thisArg, [
-        ...(entry.reverse()),
-        this,
-      ]);
-    }
-  }
-
-  get(...args) {
-    this.#ensureArgs(args, 1, 'get');
-    const name = toUSVString(args[0]);
-
-    return (this.#entries.find((it) => it.name === name) ?? {}).value ?? null;
-  }
-
-  getAll(...args) {
-    this.#ensureArgs(args, 1, 'getAll');
-    const name = toUSVString(args[0]);
-
-    return this.#entries.filter((it) => it.name === name).map((it) => it.value);
-  }
-
-  has(...args) {
-    this.#ensureArgs(args, 1, 'has');
-    const name = toUSVString(args[0]);
-
-    return !!this.#entries.find((it) => it.name === name);
-  }
-
-  set(...args) {
-    this.#ensureArgs(args, 2, 'set');
-    const entry = this.constructor.#enfoldEntry(...args);
-    const idx = this.#entries.findIndex((it) => it.name === entry.name);
-
-    if (idx !== -1) {
-      this.#entries.splice(idx, 1, entry);
-    } else {
-      this.#entries.push(entry);
-    }
-  }
-
-  * entries() {
-    for (const { name, value } of this.#entries) {
-      yield [
-        name,
-        value,
-      ];
-    }
-  }
-
-  * keys() {
-    for (const [name] of this) {
-      yield name;
-    }
-  }
-
-  * values() {
-    for (const [, value] of this) {
-      yield value;
-    }
-  }
-
-  [Symbol.iterator]() {
-    return this.entries();
-  }
-
-}
+import { randomBytes } from 'node:crypto';
+import http2 from 'node:http2';
+import { toUSVString } from 'node:util';
+import { File } from './file.mjs';
+import {
+  APPLICATION_OCTET_STREAM,
+  MULTIPART_FORM_DATA,
+} from './mediatypes.mjs';
+import {
+  collate,
+  tap,
+} from './utils.mjs';
+
+const CRLF = '\r\n';
+const {
+  HTTP2_HEADER_CONTENT_DISPOSITION,
+  HTTP2_HEADER_CONTENT_TYPE,
+} = http2.constants;
+
+export class FormData {
+
+  static actuate(fd) {
+    const boundary = randomBytes(24).toString('hex');
+    const contentType = `${ MULTIPART_FORM_DATA }; boundary=${ boundary }`;
+    const prefix = `--${ boundary }${ CRLF }${ HTTP2_HEADER_CONTENT_DISPOSITION }: form-data`;
+
+    const escape = (str) => str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22');
+    const normalize = (value) => value.replace(/\r?\n|\r/g, CRLF);
+
+    return {
+      contentType,
+      async* [Symbol.asyncIterator]() {
+        const encoder = new TextEncoder();
+
+        for (const [name, value] of fd) {
+          if (value.constructor === String) {
+            yield encoder.encode(`${ prefix }; name="${
+              escape(normalize(name))
+            }"${ CRLF.repeat(2) }${ normalize(value) }${ CRLF }`);
+          } else {
+            yield encoder.encode(`${ prefix }; name="${
+              escape(normalize(name))
+            }"${ value.name ? `; filename="${ escape(value.name) }"` : '' }${ CRLF }${
+              HTTP2_HEADER_CONTENT_TYPE
+            }: ${
+              value.type || APPLICATION_OCTET_STREAM
+            }${ CRLF.repeat(2) }`);
+            yield* tap(value);
+            yield encoder.encode(CRLF);
+          }
+        }
+
+        yield encoder.encode(`--${ boundary }--`);
+      },
+    };
+  }
+
+  static alike(instance) {
+    return instance?.constructor.name === FormData.name;
+  }
+
+  static #enfoldEntry(name, value, filename) {
+    name = toUSVString(name);
+    filename &&= toUSVString(filename);
+
+    if (File.alike(value)) {
+      value = new File([value], filename, value);
+    } else if (this.#ensureInstance(value)) {
+      value.name = filename || value.name;
+    } else {
+      value = toUSVString(value);
+    }
+
+    return {
+      name,
+      value,
+    };
+  }
+
+  static #ensureInstance(value) {
+    return File.alike(value) || (value === Object(value) && Reflect.has(value, Symbol.asyncIterator));
+  }
+
+  #entries = [];
+
+  get [Symbol.toStringTag]() {
+    return this.constructor.name;
+  }
+
+  constructor(input) {
+    if (input === Object(input)
+      && (input?.constructor === Object || Reflect.has(input, Symbol.iterator))) {
+
+      if (input.constructor !== Object) {
+        input = Array.from(input);
+      }
+
+      if (Array.isArray(input)) {
+        if (!input.every((it) => Array.isArray(it))) {
+          throw new TypeError(`Failed to construct '${
+            this[Symbol.toStringTag]
+          }': The provided value cannot be converted to a sequence.`);
+        } else if (!input.every((it) => it.length === 2)) {
+          throw new TypeError(`Failed to construct '${
+            this[Symbol.toStringTag]
+          }': Sequence initializer must only contain pair elements.`);
+        }
+      }
+
+      if (input.constructor === Object) {
+        input = Object.entries(input);
+      }
+
+      input.forEach(([key, value]) => this.append(key, value));
+    }
+  }
+
+  #ensureArgs(args, expected, method) {
+    if (args.length < expected) {
+      throw new TypeError(`Failed to execute '${ method }' on '${
+        this[Symbol.toStringTag]
+      }': ${ expected } arguments required, but only ${ args.length } present.`);
+    }
+
+    if ([
+      'append',
+      'set',
+    ].includes(method)) {
+      if (args.length === 3 && !this.constructor.#ensureInstance(args[1])) {
+        throw new TypeError(`Failed to execute '${ method }' on '${
+          this[Symbol.toStringTag]
+        }': parameter ${ expected } is not of type 'Blob', 'File' or async iterable.`);
+      }
+    }
+
+    if (method === 'forEach') {
+      if (args[0]?.constructor !== Function) {
+        throw new TypeError(`Failed to execute '${ method }' on '${
+          this[Symbol.toStringTag]
+        }': parameter ${ expected } is not of type 'Function'.`);
+      }
+    }
+  }
+
+  append(...args) {
+    collate(this, FormData);
+    this.#ensureArgs(args, 2, 'append');
+    this.#entries.push(this.constructor.#enfoldEntry(...args));
+  }
+
+  delete(...args) {
+    collate(this, FormData);
+    this.#ensureArgs(args, 1, 'delete');
+    const name = toUSVString(args[0]);
+
+    this.#entries = this.#entries.filter((it) => it.name !== name);
+  }
+
+  forEach(...args) {
+    collate(this, FormData);
+    this.#ensureArgs(args, 1, 'forEach');
+    const [callback, thisArg] = args;
+
+    for (const entry of this) {
+      Reflect.apply(callback, thisArg, [
+        ...entry.reverse(),
+        this,
+      ]);
+    }
+  }
+
+  get(...args) {
+    collate(this, FormData);
+    this.#ensureArgs(args, 1, 'get');
+    const name = toUSVString(args[0]);
+
+    return (this.#entries.find((it) => it.name === name) ?? {}).value ?? null;
+  }
+
+  getAll(...args) {
+    collate(this, FormData);
+    this.#ensureArgs(args, 1, 'getAll');
+    const name = toUSVString(args[0]);
+
+    return this.#entries.filter((it) => it.name === name).map((it) => it.value);
+  }
+
+  has(...args) {
+    collate(this, FormData);
+    this.#ensureArgs(args, 1, 'has');
+    const name = toUSVString(args[0]);
+
+    return !!this.#entries.find((it) => it.name === name);
+  }
+
+  set(...args) {
+    collate(this, FormData);
+    this.#ensureArgs(args, 2, 'set');
+    const entry = this.constructor.#enfoldEntry(...args);
+    const idx = this.#entries.findIndex((it) => it.name === entry.name);
+
+    if (idx !== -1) {
+      this.#entries.splice(idx, 1, entry);
+    } else {
+      this.#entries.push(entry);
+    }
+  }
+
+  * entries() {
+    collate(this, FormData);
+    for (const { name, value } of this.#entries) {
+      yield [
+        name,
+        value,
+      ];
+    }
+  }
+
+  * keys() {
+    collate(this, FormData);
+    for (const [name] of this) {
+      yield name;
+    }
+  }
+
+  * values() {
+    collate(this, FormData);
+    for (const [, value] of this) {
+      yield value;
+    }
+  }
+
+  [Symbol.iterator]() {
+    collate(this, FormData);
+
+    return this.entries();
+  }
+
+}

package/src/index.mjs

@@ -1,10 +1,11 @@
-import http from 'http';
-import http2 from 'http2';
-import https from 'https';
-import { setTimeout as setTimeoutPromise } from 'timers/promises';
+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 { Cookies } from './cookies.mjs';
 import { RequestError } from './errors.mjs';
+import { APPLICATION_OCTET_STREAM } from './mediatypes.mjs';
 import {
   admix,
   affix,
@@ -13,18 +14,18 @@ import {
   mixin,
   preflight,
   redirects,
+  revise,
   transform,
-} from './helpers.mjs';
-import { APPLICATION_OCTET_STREAM } from './mediatypes.mjs';
+} from './utils.mjs';
 
-export { constants } from 'http2';
+export { constants } from 'node:http2';
 
 export * from './ackn.mjs';
 export * from './cookies.mjs';
 export * from './errors.mjs';
 export * from './file.mjs';
 export * from './formdata.mjs';
-export * from './helpers.mjs';
+export * from './utils.mjs';
 
 const {
   HTTP2_HEADER_CONTENT_LENGTH,
@@ -69,7 +70,7 @@ let defaults = {
 };
 
 export default async function rekwest(url, options = {}) {
-  url = options.url = new URL(url);
+  ({ url } = revise({ options, url }));
   if (!options.redirected) {
     options = merge(rekwest.defaults, options);
   }
@@ -98,8 +99,8 @@ export default async function rekwest(url, options = {}) {
 
   options = preflight(options);
 
-  const { cookies, digest, follow, h2, redirect, redirected, thenable, url: { protocol } } = options;
-  const { request } = (protocol === 'http:' ? http : https);
+  const { cookies, digest, follow, h2, redirect, redirected, thenable } = options;
+  const { request } = (url.protocol === 'http:' ? http : https);
   let { body } = options;
 
   const promise = new Promise((resolve, reject) => {
@@ -149,7 +150,7 @@ export default async function rekwest(url, options = {}) {
 
       if (follow && /^3\d{2}$/.test(res.statusCode) && res.headers[HTTP2_HEADER_LOCATION]) {
         if (redirect === redirects.error) {
-          res.emit('error', new RequestError(`Unexpected redirect, redirect mode is set to '${ redirect }'.`));
+          return res.emit('error', new RequestError(`Unexpected redirect, redirect mode is set to '${ redirect }'.`));
         }
 
         if (redirect === redirects.follow) {
@@ -157,7 +158,7 @@ export default async function rekwest(url, options = {}) {
 
           if (res.statusCode !== HTTP_STATUS_SEE_OTHER
             && body === Object(body) && body.pipe?.constructor === Function) {
-            res.emit('error', new RequestError(`Unable to ${ redirect } redirect with body as readable stream.`));
+            return res.emit('error', new RequestError(`Unable to ${ redirect } redirect with streamable body.`));
           }
 
           options.follow--;
@@ -176,7 +177,7 @@ export default async function rekwest(url, options = {}) {
             interval = Number(interval) * 1000 || new Date(interval) - Date.now();
 
             if (interval > options.maxRetryAfter) {
-              res.emit('error', maxRetryAfterError(interval, { cause: mixin(res, options) }));
+              return res.emit('error', maxRetryAfterError(interval, { cause: mixin(res, options) }));
             }
 
             return setTimeoutPromise(interval).then(() => rekwest(options.url, options).then(resolve, reject));
@@ -240,24 +241,24 @@ export default async function rekwest(url, options = {}) {
 
 Reflect.defineProperty(rekwest, 'stream', {
   enumerable: true,
-  value: function (url, options = {}) {
+  value(url, options = {}) {
+    ({ url } = revise({ options, url }));
     options = preflight({
-      url,
       ...merge(rekwest.defaults, {
         headers: { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_OCTET_STREAM },
       }, options),
       redirect: redirects.manual,
     });
 
-    const { h2, url: { protocol } } = options;
-    const { request } = (protocol === 'http:' ? http : https);
+    const { h2 } = options;
+    const { request } = (url.protocol === 'http:' ? http : https);
     let client, req;
 
     if (h2) {
       client = http2.connect(url.origin, options);
       req = client.request(options.headers, options);
     } else {
-      req = request(options.url, options);
+      req = request(url, options);
     }
 
     affix(client, req, options);