@gjsify/fetch 0.3.13 → 0.3.15

package/lib/esm/body.js

@@ -1,327 +1,349 @@
-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 { FetchError } from "./errors/fetch-error.js";
 import { isBlob, isURLSearchParameters } from "./utils/is.js";
-const pipeline = (source, dest) => new Promise((resolve, reject) => {
-  pipelineCb(source, dest, (err) => {
-    if (err) reject(err);
-    else resolve();
-  });
+import { URLSearchParams } from "@gjsify/url";
+import { Buffer } from "node:buffer";
+import { PassThrough, Readable, Stream as Stream$1, pipeline } from "node:stream";
+import { FormData, formDataToBlob } from "@gjsify/formdata";
+
+//#region src/body.ts
+const pipeline$1 = (source, dest) => new Promise((resolve, reject) => {
+	pipeline(source, dest, (err) => {
+		if (err) reject(err);
+		else resolve();
+	});
 });
-const INTERNALS = /* @__PURE__ */ Symbol("Body internals");
+const INTERNALS = Symbol("Body internals");
 function isAnyArrayBuffer(val) {
-  return val instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && val instanceof SharedArrayBuffer;
+	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,
-    stream: null,
-    boundary: "",
-    disturbed: false,
-    error: null
-  };
-  size = 0;
-  constructor(body, options = { size: 0 }) {
-    this.size = options.size || 0;
-    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)) {
-      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 (typeof ReadableStream !== "undefined" && body instanceof ReadableStream) {
-      this[INTERNALS].body = readableStreamToReadable(body);
-    } else if (body instanceof FormData) {
-      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 = Buffer.from(String(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 (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() {
-    const stream = this[INTERNALS].stream;
-    if (!stream) return null;
-    if (typeof ReadableStream !== "undefined") {
-      let closed = false;
-      return new ReadableStream({
-        start(controller) {
-          stream.on("data", (chunk) => {
-            if (closed) return;
-            try {
-              controller.enqueue(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
-            } catch {
-            }
-          });
-          stream.on("end", () => {
-            if (closed) return;
-            closed = true;
-            try {
-              controller.close();
-            } catch {
-            }
-          });
-          stream.on("error", (err) => {
-            if (closed) return;
-            closed = true;
-            try {
-              controller.error(err);
-            } catch {
-            }
-          });
-        },
-        cancel() {
-          closed = true;
-          stream.destroy();
-        }
-      });
-    }
-    return null;
-  }
-  get _stream() {
-    return this[INTERNALS].stream;
-  }
-  /** Return the raw body buffer without consuming the stream (used by Request._send). */
-  get _rawBodyBuffer() {
-    const b = this[INTERNALS].body;
-    if (b === null) return null;
-    if (Buffer.isBuffer(b)) return b;
-    if (b instanceof Uint8Array) return Buffer.from(b.buffer, b.byteOffset, b.byteLength);
-    return null;
-  }
-  get bodyUsed() {
-    return this[INTERNALS].disturbed;
-  }
-  /**
-   * Decode response as ArrayBuffer
-   */
-  async arrayBuffer() {
-    const { buffer, byteOffset, byteLength } = await consumeBody(this);
-    return buffer.slice(byteOffset, byteOffset + byteLength);
-  }
-  async formData() {
-    const ct = this.headers?.get("content-type");
-    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) {
-        formData.append(name, value);
-      }
-      return formData;
-    }
-    const { toFormData } = await import("./utils/multipart-parser.js");
-    return toFormData(this.body, ct);
-  }
-  /**
-   * Return raw response as Blob
-   */
-  async blob() {
-    const ct = this.headers?.get("content-type") || this[INTERNALS].body && this[INTERNALS].body.type || "";
-    const buf = await this.arrayBuffer();
-    return new Blob([buf], {
-      type: ct
-    });
-  }
-  /**
-   * Decode response as json
-   */
-  async json() {
-    const text = await this.text();
-    return JSON.parse(text);
-  }
-  /**
-   * Decode response as text
-   */
-  async text() {
-    const buffer = await consumeBody(this);
-    return new TextDecoder().decode(buffer);
-  }
+	return val instanceof String || val instanceof Number || val instanceof Boolean || typeof Symbol !== "undefined" && val instanceof Symbol || typeof BigInt !== "undefined" && val instanceof BigInt;
 }
+/**
+* Body mixin
+*
+* Ref: https://fetch.spec.whatwg.org/#body
+*
+* @param body Readable stream
+* @param opts Response options
+*/
+var Body = class {
+	[INTERNALS] = {
+		body: null,
+		stream: null,
+		boundary: "",
+		disturbed: false,
+		error: null
+	};
+	size = 0;
+	constructor(body, options = { size: 0 }) {
+		this.size = options.size || 0;
+		if (body === null || body === undefined) {
+			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)) {
+			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 (typeof ReadableStream !== "undefined" && body instanceof ReadableStream) {
+			this[INTERNALS].body = readableStreamToReadable(body);
+		} else if (body instanceof FormData) {
+			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 = Buffer.from(String(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 (b instanceof Stream$1) {
+			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() {
+		const stream = this[INTERNALS].stream;
+		if (!stream) return null;
+		if (typeof ReadableStream !== "undefined") {
+			let closed = false;
+			return new ReadableStream({
+				start(controller) {
+					stream.on("data", (chunk) => {
+						if (closed) return;
+						try {
+							controller.enqueue(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
+						} catch {}
+					});
+					stream.on("end", () => {
+						if (closed) return;
+						closed = true;
+						try {
+							controller.close();
+						} catch {}
+					});
+					stream.on("error", (err) => {
+						if (closed) return;
+						closed = true;
+						try {
+							controller.error(err);
+						} catch {}
+					});
+				},
+				cancel() {
+					closed = true;
+					stream.destroy();
+				}
+			});
+		}
+		return null;
+	}
+	get _stream() {
+		return this[INTERNALS].stream;
+	}
+	/** Return the raw body buffer without consuming the stream (used by Request._send). */
+	get _rawBodyBuffer() {
+		const b = this[INTERNALS].body;
+		if (b === null) return null;
+		if (Buffer.isBuffer(b)) return b;
+		if (b instanceof Uint8Array) return Buffer.from(b.buffer, b.byteOffset, b.byteLength);
+		return null;
+	}
+	get bodyUsed() {
+		return this[INTERNALS].disturbed;
+	}
+	/**
+	* Decode response as ArrayBuffer
+	*/
+	async arrayBuffer() {
+		const { buffer, byteOffset, byteLength } = await consumeBody(this);
+		return buffer.slice(byteOffset, byteOffset + byteLength);
+	}
+	async formData() {
+		const ct = this.headers?.get("content-type");
+		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) {
+				formData.append(name, value);
+			}
+			return formData;
+		}
+		const { toFormData } = await import("./utils/multipart-parser.js");
+		return toFormData(this.body, ct);
+	}
+	/**
+	* Return raw response as Blob
+	*/
+	async blob() {
+		const ct = this.headers?.get("content-type") || this[INTERNALS].body && this[INTERNALS].body.type || "";
+		const buf = await this.arrayBuffer();
+		return new Blob([buf], { type: ct });
+	}
+	/**
+	* Decode response as json
+	*/
+	async json() {
+		const text = await this.text();
+		return JSON.parse(text);
+	}
+	/**
+	* Decode response as text
+	*/
+	async text() {
+		const buffer = await consumeBody(this);
+		return new TextDecoder().decode(buffer);
+	}
+};
 Object.defineProperties(Body.prototype, {
-  body: { enumerable: true },
-  bodyUsed: { enumerable: true },
-  arrayBuffer: { enumerable: true },
-  blob: { enumerable: true },
-  json: { enumerable: true },
-  text: { enumerable: true }
+	body: { enumerable: true },
+	bodyUsed: { enumerable: true },
+	arrayBuffer: { enumerable: true },
+	blob: { enumerable: true },
+	json: { enumerable: true },
+	text: { enumerable: true }
 });
+/**
+* Consume and convert an entire Body to a Buffer.
+*/
 async function consumeBody(data) {
-  if (data[INTERNALS].disturbed) {
-    throw new TypeError(`body used already for: ${data.url}`);
-  }
-  data[INTERNALS].disturbed = true;
-  if (data[INTERNALS].error) {
-    throw data[INTERNALS].error;
-  }
-  const { _stream: body } = data;
-  if (body === null) {
-    return Buffer.alloc(0);
-  }
-  if (!(body instanceof Stream)) {
-    return Buffer.alloc(0);
-  }
-  const accum = [];
-  let accumBytes = 0;
-  try {
-    for await (const chunk of body) {
-      if (data.size > 0 && accumBytes + chunk.length > data.size) {
-        const error = new FetchError(`content size at ${data.url} over limit: ${data.size}`, "max-size");
-        body.destroy(error);
-        throw error;
-      }
-      accumBytes += chunk.length;
-      accum.push(chunk);
-    }
-  } catch (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_;
-  }
-  try {
-    if (accum.every((c) => typeof c === "string")) {
-      return Buffer.from(accum.join(""));
-    }
-    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);
-  }
+	if (data[INTERNALS].disturbed) {
+		throw new TypeError(`body used already for: ${data.url}`);
+	}
+	data[INTERNALS].disturbed = true;
+	if (data[INTERNALS].error) {
+		throw data[INTERNALS].error;
+	}
+	const { _stream: body } = data;
+	if (body === null) {
+		return Buffer.alloc(0);
+	}
+	if (!(body instanceof Stream$1)) {
+		return Buffer.alloc(0);
+	}
+	const accum = [];
+	let accumBytes = 0;
+	try {
+		for await (const chunk of body) {
+			if (data.size > 0 && accumBytes + chunk.length > data.size) {
+				const error = new FetchError(`content size at ${data.url} over limit: ${data.size}`, "max-size");
+				body.destroy(error);
+				throw error;
+			}
+			accumBytes += chunk.length;
+			accum.push(chunk);
+		}
+	} catch (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_;
+	}
+	try {
+		if (accum.every((c) => typeof c === "string")) {
+			return Buffer.from(accum.join(""));
+		}
+		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);
+	}
 }
+/**
+* Clone body given Res/Req instance
+*/
 const clone = (instance, highWaterMark) => {
-  let p1;
-  let p2;
-  let { body } = instance[INTERNALS];
-  if (instance.bodyUsed) {
-    throw new Error("cannot clone body after it is used");
-  }
-  if (body instanceof Stream && typeof body.getBoundary !== "function") {
-    p1 = new PassThrough({ highWaterMark });
-    p2 = new PassThrough({ highWaterMark });
-    body.pipe(p1);
-    body.pipe(p2);
-    instance[INTERNALS].stream = p1;
-    body = p2;
-  }
-  return body;
+	let p1;
+	let p2;
+	let { body } = instance[INTERNALS];
+	if (instance.bodyUsed) {
+		throw new Error("cannot clone body after it is used");
+	}
+	if (body instanceof Stream$1 && typeof body.getBoundary !== "function") {
+		p1 = new PassThrough({ highWaterMark });
+		p2 = new PassThrough({ highWaterMark });
+		body.pipe(p1);
+		body.pipe(p2);
+		instance[INTERNALS].stream = p1;
+		body = p2;
+	}
+	return body;
 };
+/**
+* Extract a Content-Type value from a body.
+*/
 const extractContentType = (body, request) => {
-  if (body === null) {
-    return null;
-  }
-  if (typeof body === "string") {
-    return "text/plain;charset=UTF-8";
-  }
-  if (isURLSearchParameters(body)) {
-    return "application/x-www-form-urlencoded;charset=UTF-8";
-  }
-  if (isBlob(body)) {
-    return body.type || null;
-  }
-  if (Buffer.isBuffer(body) || isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
-    return null;
-  }
-  if (body instanceof FormData) {
-    return `multipart/form-data; boundary=${request[INTERNALS].boundary}`;
-  }
-  if (body instanceof Stream) {
-    return null;
-  }
-  return "text/plain;charset=UTF-8";
+	if (body === null) {
+		return null;
+	}
+	if (typeof body === "string") {
+		return "text/plain;charset=UTF-8";
+	}
+	if (isURLSearchParameters(body)) {
+		return "application/x-www-form-urlencoded;charset=UTF-8";
+	}
+	if (isBlob(body)) {
+		return body.type || null;
+	}
+	if (Buffer.isBuffer(body) || isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
+		return null;
+	}
+	if (body instanceof FormData) {
+		return `multipart/form-data; boundary=${request[INTERNALS].boundary}`;
+	}
+	if (body instanceof Stream$1) {
+		return null;
+	}
+	return "text/plain;charset=UTF-8";
 };
+/**
+* Get total bytes of a body.
+*/
 const getTotalBytes = (request) => {
-  const { body } = request[INTERNALS];
-  if (body === null) {
-    return 0;
-  }
-  if (isBlob(body)) {
-    return body.size;
-  }
-  if (Buffer.isBuffer(body)) {
-    return body.length;
-  }
-  if (body && typeof body.getLengthSync === "function") {
-    const streamBody = body;
-    return streamBody.hasKnownLength && streamBody.hasKnownLength() ? streamBody.getLengthSync() : null;
-  }
-  return null;
+	const { body } = request[INTERNALS];
+	if (body === null) {
+		return 0;
+	}
+	if (isBlob(body)) {
+		return body.size;
+	}
+	if (Buffer.isBuffer(body)) {
+		return body.length;
+	}
+	if (body && typeof body.getLengthSync === "function") {
+		const streamBody = body;
+		return streamBody.hasKnownLength && streamBody.hasKnownLength() ? streamBody.getLengthSync() : null;
+	}
+	return null;
 };
+/**
+* Write a Body to a Node.js WritableStream.
+*/
 const writeToStream = async (dest, { body }) => {
-  if (body === null) {
-    dest.end();
-  } else {
-    await pipeline(body, dest);
-  }
+	if (body === null) {
+		dest.end();
+	} else {
+		await pipeline$1(body, dest);
+	}
 };
+/**
+* Convert a Web ReadableStream to a Node.js Readable.
+*/
 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);
-    }
-  });
+	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);
+		}
+	});
 }
+/**
+* Convert a Blob to an async iterable for Readable.from().
+*/
 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());
-  }
+	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,
-  extractContentType,
-  getTotalBytes,
-  writeToStream
-};
+
+//#endregion
+export { clone, Body as default, extractContentType, getTotalBytes, writeToStream };

package/lib/esm/errors/abort-error.js

@@ -1,9 +1,14 @@
 import { FetchBaseError } from "./base.js";
-class AbortError extends FetchBaseError {
-  constructor(message, type = "aborted") {
-    super(message, type);
-  }
-}
-export {
-  AbortError
+
+//#region src/errors/abort-error.ts
+/**
+* AbortError interface for cancelled requests
+*/
+var AbortError = class extends FetchBaseError {
+	constructor(message, type = "aborted") {
+		super(message, type);
+	}
 };
+
+//#endregion
+export { AbortError };