@gjsify/fetch 0.0.4 → 0.1.1

package/lib/esm/body.js

@@ -1,15 +1,24 @@
-import { URLSearchParams } from "@gjsify/deno-runtime/ext/url/00_url";
-import { Blob } from "@gjsify/deno-runtime/ext/web/09_file";
-import { PassThrough, pipeline as pipelineCb, Readable, Stream } from "stream";
-import { ReadableStream as StreamWebReadableStream } from "stream/web";
-import { types, deprecate, promisify } from "util";
-import { Buffer } from "buffer";
-import { FormData, formDataToBlob } from "formdata-polyfill/esm.min.js";
+import { URLSearchParams } from "@gjsify/url";
+import { Blob } from "./utils/blob-from.js";
+import { PassThrough, pipeline as pipelineCb, Readable, Stream } from "node:stream";
+import { Buffer } from "node:buffer";
+import { FormData, formDataToBlob } from "@gjsify/formdata";
 import { FetchError } from "./errors/fetch-error.js";
 import { FetchBaseError } from "./errors/base.js";
 import { isBlob, isURLSearchParameters } from "./utils/is.js";
-const pipeline = promisify(pipelineCb);
-const INTERNALS = Symbol("Body internals");
+const pipeline = (source, dest) => new Promise((resolve, reject) => {
+  pipelineCb(source, dest, (err) => {
+    if (err) reject(err);
+    else resolve();
+  });
+});
+const INTERNALS = /* @__PURE__ */ Symbol("Body internals");
+function isAnyArrayBuffer(val) {
+  return val instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && val instanceof SharedArrayBuffer;
+}
+function isBoxedPrimitive(val) {
+  return val instanceof String || val instanceof Number || val instanceof Boolean || typeof Symbol !== "undefined" && val instanceof Symbol || typeof BigInt !== "undefined" && val instanceof BigInt;
+}
 class Body {
   [INTERNALS] = {
     body: null,
@@ -21,47 +30,71 @@ class Body {
   size = 0;
   constructor(body, options = { size: 0 }) {
     this.size = options.size || 0;
-    if (body === null) {
+    if (body === null || body === void 0) {
       this[INTERNALS].body = null;
     } else if (isURLSearchParameters(body)) {
       this[INTERNALS].body = Buffer.from(body.toString());
     } else if (isBlob(body)) {
+      this[INTERNALS].body = body;
     } else if (Buffer.isBuffer(body)) {
-    } else if (types.isAnyArrayBuffer(body)) {
+      this[INTERNALS].body = body;
+    } else if (isAnyArrayBuffer(body)) {
       this[INTERNALS].body = Buffer.from(body);
     } else if (ArrayBuffer.isView(body)) {
       this[INTERNALS].body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
     } else if (body instanceof Readable) {
       this[INTERNALS].body = body;
-    } else if (body instanceof ReadableStream || body instanceof StreamWebReadableStream) {
-      this[INTERNALS].body = Readable.fromWeb(body);
+    } else if (typeof ReadableStream !== "undefined" && body instanceof ReadableStream) {
+      this[INTERNALS].body = readableStreamToReadable(body);
     } else if (body instanceof FormData) {
-      this[INTERNALS].body = formDataToBlob(body);
-      this[INTERNALS].boundary = this[INTERNALS].body.type.split("=")[1];
+      const blob = formDataToBlob(body);
+      this[INTERNALS].body = blob;
+      this[INTERNALS].boundary = blob.type?.split("boundary=")?.[1] ?? "";
     } else if (typeof body === "string") {
       this[INTERNALS].body = Buffer.from(body);
     } else if (body instanceof URLSearchParams) {
       this[INTERNALS].body = Buffer.from(body.toString());
     } else {
       console.warn(`Unknown body type "${typeof body}", try to parse the body to string!`);
-      this[INTERNALS].body = Readable.from(typeof body.toString === "function" ? body.toString() : body);
+      this[INTERNALS].body = Buffer.from(String(body));
     }
-    if (Buffer.isBuffer(body)) {
-      this[INTERNALS].stream = Readable.from(body);
-    } else if (isBlob(body)) {
-      this[INTERNALS].stream = Readable.from(body.stream());
-    } else if (body instanceof Readable) {
-      this[INTERNALS].stream = body;
+    const b = this[INTERNALS].body;
+    if (Buffer.isBuffer(b)) {
+      this[INTERNALS].stream = Readable.from(b);
+    } else if (isBlob(b)) {
+      this[INTERNALS].stream = Readable.from(blobToAsyncIterable(b));
+    } else if (b instanceof Readable) {
+      this[INTERNALS].stream = b;
     }
-    if (body instanceof Stream) {
-      body.on("error", (error_) => {
+    if (b instanceof Stream) {
+      b.on("error", (error_) => {
         const error = error_ instanceof FetchBaseError ? error_ : new FetchError(`Invalid response body while trying to fetch ${this.url}: ${error_.message}`, "system", error_);
         this[INTERNALS].error = error;
       });
     }
   }
   get body() {
-    return Readable.toWeb(this[INTERNALS].stream);
+    const stream = this[INTERNALS].stream;
+    if (!stream) return null;
+    if (typeof ReadableStream !== "undefined") {
+      return new ReadableStream({
+        start(controller) {
+          stream.on("data", (chunk) => {
+            controller.enqueue(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
+          });
+          stream.on("end", () => {
+            controller.close();
+          });
+          stream.on("error", (err) => {
+            controller.error(err);
+          });
+        },
+        cancel() {
+          stream.destroy();
+        }
+      });
+    }
+    return null;
   }
   get _stream() {
     return this[INTERNALS].stream;
@@ -71,8 +104,6 @@ class Body {
   }
   /**
    * Decode response as ArrayBuffer
-   *
-   * @return  Promise
    */
   async arrayBuffer() {
     const { buffer, byteOffset, byteLength } = await consumeBody(this);
@@ -80,7 +111,7 @@ class Body {
   }
   async formData() {
     const ct = this.headers?.get("content-type");
-    if (ct.startsWith("application/x-www-form-urlencoded")) {
+    if (ct?.startsWith("application/x-www-form-urlencoded")) {
       const formData = new FormData();
       const parameters = new URLSearchParams(await this.text());
       for (const [name, value] of parameters) {
@@ -93,10 +124,7 @@ class Body {
   }
   /**
    * Return raw response as Blob
-   *
-   * @return Promise
    */
-  // @ts-ignore
   async blob() {
     const ct = this.headers?.get("content-type") || this[INTERNALS].body && this[INTERNALS].body.type || "";
     const buf = await this.arrayBuffer();
@@ -106,8 +134,6 @@ class Body {
   }
   /**
    * Decode response as json
-   *
-   * @return  Promise
    */
   async json() {
     const text = await this.text();
@@ -115,8 +141,6 @@ class Body {
   }
   /**
    * Decode response as text
-   *
-   * @return  Promise
    */
   async text() {
     const buffer = await consumeBody(this);
@@ -129,13 +153,7 @@ Object.defineProperties(Body.prototype, {
   arrayBuffer: { enumerable: true },
   blob: { enumerable: true },
   json: { enumerable: true },
-  text: { enumerable: true },
-  data: { get: deprecate(
-    () => {
-    },
-    "data doesn't exist, use json(), text(), arrayBuffer(), or body instead",
-    "https://github.com/node-fetch/node-fetch/issues/1000 (response)"
-  ) }
+  text: { enumerable: true }
 });
 async function consumeBody(data) {
   if (data[INTERNALS].disturbed) {
@@ -165,20 +183,18 @@ async function consumeBody(data) {
       accum.push(chunk);
     }
   } catch (error) {
-    const error_ = error instanceof FetchBaseError ? error : new FetchError(`Invalid response body while trying to fetch ${data.url}: ${error.message}`, "system", error);
+    const err = error instanceof Error ? error : new Error(String(error));
+    const error_ = error instanceof FetchBaseError ? error : new FetchError(`Invalid response body while trying to fetch ${data.url}: ${err.message}`, "system", err);
     throw error_;
   }
-  if (body.readableEnded === true || body._readableState.ended === true) {
-    try {
-      if (accum.every((c) => typeof c === "string")) {
-        return Buffer.from(accum.join(""));
-      }
-      return Buffer.concat(accum, accumBytes);
-    } catch (error) {
-      throw new FetchError(`Could not create Buffer from response body for ${data.url}: ${error.message}`, "system", error);
+  try {
+    if (accum.every((c) => typeof c === "string")) {
+      return Buffer.from(accum.join(""));
     }
-  } else {
-    throw new FetchError(`Premature close of server response while trying to fetch ${data.url}`);
+    return Buffer.concat(accum, accumBytes);
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    throw new FetchError(`Could not create Buffer from response body for ${data.url}: ${err.message}`, "system", err);
   }
 }
 const clone = (instance, highWaterMark) => {
@@ -211,7 +227,7 @@ const extractContentType = (body, request) => {
   if (isBlob(body)) {
     return body.type || null;
   }
-  if (Buffer.isBuffer(body) || types.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
+  if (Buffer.isBuffer(body) || isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
     return null;
   }
   if (body instanceof FormData) {
@@ -234,8 +250,8 @@ const getTotalBytes = (request) => {
     return body.length;
   }
   if (body && typeof body.getLengthSync === "function") {
-    const anyBody = body;
-    return anyBody.hasKnownLength && anyBody.hasKnownLength() ? anyBody.getLengthSync() : null;
+    const streamBody = body;
+    return streamBody.hasKnownLength && streamBody.hasKnownLength() ? streamBody.getLengthSync() : null;
   }
   return null;
 };
@@ -246,6 +262,38 @@ const writeToStream = async (dest, { body }) => {
     await pipeline(body, dest);
   }
 };
+function readableStreamToReadable(webStream) {
+  const reader = webStream.getReader();
+  return new Readable({
+    async read() {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          this.push(null);
+        } else {
+          this.push(Buffer.from(value));
+        }
+      } catch (err) {
+        this.destroy(err);
+      }
+    },
+    destroy(_err, callback) {
+      reader.cancel().then(() => callback(null), callback);
+    }
+  });
+}
+async function* blobToAsyncIterable(blob) {
+  if (typeof blob.stream === "function") {
+    const reader = blob.stream().getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      yield value;
+    }
+  } else {
+    yield new Uint8Array(await blob.arrayBuffer());
+  }
+}
 export {
   clone,
   Body as default,

package/lib/esm/errors/base.js

@@ -2,7 +2,9 @@ class FetchBaseError extends Error {
   type;
   constructor(message, type) {
     super(message);
-    Error.captureStackTrace(this, this.constructor);
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, this.constructor);
+    }
     this.type = type;
   }
   get name() {

package/lib/esm/headers.js

@@ -1,122 +1,80 @@
 import Soup from "@girs/soup-3.0";
-import { URLSearchParams } from "@gjsify/deno-runtime/ext/url/00_url";
-import { types } from "util";
-import * as http from "http";
-const validateHeaderName = http.validateHeaderName;
-const validateHeaderValue = http.validateHeaderValue;
-class Headers extends URLSearchParams {
-  /**
-   * Headers class
-   *
-   * @constructor
-   * @param init Response headers
-   */
+import { validateHeaderName, validateHeaderValue } from "@gjsify/http";
+const _headers = /* @__PURE__ */ Symbol("Headers.headers");
+function isBoxedPrimitive(val) {
+  return val instanceof String || val instanceof Number || val instanceof Boolean || typeof Symbol !== "undefined" && val instanceof Symbol || typeof BigInt !== "undefined" && val instanceof BigInt;
+}
+class Headers {
+  [_headers];
   constructor(init) {
-    let result = [];
+    this[_headers] = /* @__PURE__ */ new Map();
+    if (init == null) {
+      return;
+    }
     if (init instanceof Headers) {
-      const raw = init.raw();
-      for (const [name, values] of Object.entries(raw)) {
-        result.push(...values.map((value) => [name, value]));
+      for (const [name, values] of init[_headers]) {
+        this[_headers].set(name, [...values]);
       }
-    } else if (init == null) {
-    } else if (typeof init === "object" && !types.isBoxedPrimitive(init)) {
+      return;
+    }
+    if (typeof init === "object" && !isBoxedPrimitive(init)) {
       const method = init[Symbol.iterator];
       if (method == null) {
-        result.push(...Object.entries(init));
+        for (const [name, value] of Object.entries(init)) {
+          validateHeaderName(name);
+          validateHeaderValue(name, String(value));
+          this.append(name, String(value));
+        }
       } else {
         if (typeof method !== "function") {
           throw new TypeError("Header pairs must be iterable");
         }
-        result = [...init].map((pair) => {
-          if (typeof pair !== "object" || types.isBoxedPrimitive(pair)) {
+        for (const pair of init) {
+          if (typeof pair !== "object" || isBoxedPrimitive(pair)) {
             throw new TypeError("Each header pair must be an iterable object");
           }
-          return [...pair];
-        }).map((pair) => {
-          if (pair.length !== 2) {
+          const arr = [...pair];
+          if (arr.length !== 2) {
             throw new TypeError("Each header pair must be a name/value tuple");
           }
-          return [...pair];
-        });
+          validateHeaderName(arr[0]);
+          validateHeaderValue(arr[0], String(arr[1]));
+          this.append(arr[0], String(arr[1]));
+        }
       }
     } else {
-      throw new TypeError("Failed to construct 'Headers': The provided value is not of type '(sequence<sequence<ByteString>> or record<ByteString, ByteString>)");
+      throw new TypeError(
+        "Failed to construct 'Headers': The provided value is not of type '(sequence<sequence<ByteString>> or record<ByteString, ByteString>)'"
+      );
     }
-    result = result.length > 0 ? result.map(([name, value]) => {
-      validateHeaderName(name);
-      validateHeaderValue(name, String(value));
-      return [String(name).toLowerCase(), String(value)];
-    }) : void 0;
-    super(result);
-    return new Proxy(this, {
-      get(target, p, receiver) {
-        switch (p) {
-          case "append":
-          case "set":
-            return (name, value) => {
-              validateHeaderName(name);
-              validateHeaderValue(name, String(value));
-              return URLSearchParams.prototype[p].call(
-                target,
-                String(name).toLowerCase(),
-                String(value)
-              );
-            };
-          case "delete":
-          case "has":
-          case "getAll":
-            return (name) => {
-              validateHeaderName(name);
-              return URLSearchParams.prototype[p].call(
-                target,
-                String(name).toLowerCase()
-              );
-            };
-          case "keys":
-            return () => {
-              target.sort();
-              return new Set(URLSearchParams.prototype.keys.call(target)).keys();
-            };
-          default:
-            return Reflect.get(target, p, receiver);
-        }
-      }
-    });
   }
-  get [Symbol.toStringTag]() {
-    return this.constructor.name;
+  append(name, value) {
+    validateHeaderName(name);
+    validateHeaderValue(name, value);
+    const lowerName = String(name).toLowerCase();
+    const strValue = String(value);
+    const existing = this[_headers].get(lowerName);
+    if (existing) {
+      existing.push(strValue);
+    } else {
+      this[_headers].set(lowerName, [strValue]);
+    }
   }
-  toString() {
-    return Object.prototype.toString.call(this);
+  set(name, value) {
+    validateHeaderName(name);
+    validateHeaderValue(name, value);
+    const lowerName = String(name).toLowerCase();
+    this[_headers].set(lowerName, [String(value)]);
   }
-  _appendToSoupMessage(message, type = Soup.MessageHeadersType.REQUEST) {
-    const soupHeaders = message ? message.get_request_headers() : new Soup.MessageHeaders(type);
-    for (const header in this.entries()) {
-      soupHeaders.append(header, this.get(header));
-    }
-    return soupHeaders;
+  delete(name) {
+    this[_headers].delete(String(name).toLowerCase());
   }
-  static _newFromSoupMessage(message, type = Soup.MessageHeadersType.RESPONSE) {
-    let soupHeaders;
-    const headers = new Headers();
-    if (type === Soup.MessageHeadersType.RESPONSE) {
-      soupHeaders = message.get_response_headers();
-    } else if (type === Soup.MessageHeadersType.REQUEST) {
-      soupHeaders = message.get_request_headers();
-    } else {
-      for (const header in message.get_request_headers()) {
-        headers.append(header, soupHeaders[header]);
-      }
-      soupHeaders = message.get_response_headers();
-    }
-    for (const header in soupHeaders) {
-      headers.append(header, soupHeaders[header]);
-    }
-    return headers;
+  has(name) {
+    return this[_headers].has(String(name).toLowerCase());
   }
   get(name) {
-    const values = this.getAll(name);
-    if (values.length === 0) {
+    const values = this[_headers].get(String(name).toLowerCase());
+    if (!values || values.length === 0) {
       return null;
     }
     let value = values.join(", ");
@@ -125,19 +83,32 @@ class Headers extends URLSearchParams {
     }
     return value;
   }
-  forEach(callback, thisArg = void 0) {
+  getAll(name) {
+    return this[_headers].get(String(name).toLowerCase()) ?? [];
+  }
+  getSetCookie() {
+    return this[_headers].get("set-cookie") ?? [];
+  }
+  forEach(callback, thisArg) {
     for (const name of this.keys()) {
       Reflect.apply(callback, thisArg, [this.get(name), name, this]);
     }
   }
+  *keys() {
+    const sorted = [...this[_headers].keys()].sort();
+    const seen = /* @__PURE__ */ new Set();
+    for (const key of sorted) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        yield key;
+      }
+    }
+  }
   *values() {
     for (const name of this.keys()) {
       yield this.get(name);
     }
   }
-  /**
-   * 
-   */
   *entries() {
     for (const name of this.keys()) {
       yield [name, this.get(name)];
@@ -146,29 +117,62 @@ class Headers extends URLSearchParams {
   [Symbol.iterator]() {
     return this.entries();
   }
+  get [Symbol.toStringTag]() {
+    return "Headers";
+  }
+  toString() {
+    return Object.prototype.toString.call(this);
+  }
   /**
-   * Node-fetch non-spec method
-   * returning all headers and their values as array
+   * Node-fetch non-spec method: return all headers and their values as arrays.
    */
   raw() {
-    return [...this.keys()].reduce((result, key) => {
-      result[key] = this.getAll(key);
-      return result;
-    }, {});
+    const result = {};
+    for (const name of this.keys()) {
+      result[name] = this.getAll(name);
+    }
+    return result;
   }
   /**
-   * For better console.log(headers) and also to convert Headers into Node.js Request compatible format
+   * Append all headers to a Soup.Message for sending.
    */
-  [Symbol.for("nodejs.util.inspect.custom")]() {
-    return [...this.keys()].reduce((result, key) => {
+  _appendToSoupMessage(message, type = Soup.MessageHeadersType.REQUEST) {
+    const soupHeaders = message ? message.get_request_headers() : new Soup.MessageHeaders(type);
+    for (const [name, value] of this.entries()) {
+      soupHeaders.append(name, value);
+    }
+    return soupHeaders;
+  }
+  /**
+   * Create a Headers instance from a Soup.Message's headers.
+   */
+  static _newFromSoupMessage(message, type = Soup.MessageHeadersType.RESPONSE) {
+    const headers = new Headers();
+    let soupHeaders;
+    if (type === Soup.MessageHeadersType.RESPONSE) {
+      soupHeaders = message.get_response_headers();
+    } else {
+      soupHeaders = message.get_request_headers();
+    }
+    soupHeaders.foreach((name, value) => {
+      headers.append(name, value);
+    });
+    return headers;
+  }
+  /**
+   * For better console.log(headers)
+   */
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    const result = {};
+    for (const key of this.keys()) {
       const values = this.getAll(key);
       if (key === "host") {
         result[key] = values[0];
       } else {
         result[key] = values.length > 1 ? values : values[0];
       }
-      return result;
-    }, {});
+    }
+    return result;
   }
 }
 Object.defineProperties(
@@ -178,25 +182,6 @@ Object.defineProperties(
     return result;
   }, {})
 );
-function fromRawHeaders(headers = []) {
-  return new Headers(
-    headers.reduce((result, value, index, array) => {
-      if (index % 2 === 0) {
-        result.push(array.slice(index, index + 2));
-      }
-      return result;
-    }, []).filter(([name, value]) => {
-      try {
-        validateHeaderName(name);
-        validateHeaderValue(name, String(value));
-        return true;
-      } catch {
-        return false;
-      }
-    })
-  );
-}
 export {
-  Headers as default,
-  fromRawHeaders
+  Headers as default
 };