@gjsify/fetch 0.0.2

package/README.md

@@ -0,0 +1,9 @@
+# @gjsify/fetch
+
+Web and Node.js >= 18 fetch module for Gjs
+
+## Inspirations and credits
+- https://github.com/sonnyp/troll/blob/main/src/std/fetch.js
+- https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node-fetch
+- https://github.com/node-fetch/node-fetch
+- https://github.com/denoland/deno/tree/main/ext/fetch

package/lib/cjs/body.js

@@ -0,0 +1,284 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var body_exports = {};
+__export(body_exports, {
+  clone: () => clone,
+  default: () => Body,
+  extractContentType: () => extractContentType,
+  getTotalBytes: () => getTotalBytes,
+  writeToStream: () => writeToStream
+});
+module.exports = __toCommonJS(body_exports);
+var import_url = require("@gjsify/deno-runtime/ext/url/00_url");
+var import_file = require("@gjsify/deno-runtime/ext/web/09_file");
+var import_stream = require("stream");
+var import_web = require("stream/web");
+var import_util = require("util");
+var import_buffer = require("buffer");
+var import_esm_min = require("formdata-polyfill/esm.min.js");
+var import_fetch_error = require("./errors/fetch-error.js");
+var import_base = require("./errors/base.js");
+var import_is = require("./utils/is.js");
+const pipeline = (0, import_util.promisify)(import_stream.pipeline);
+const INTERNALS = Symbol("Body internals");
+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) {
+      this[INTERNALS].body = null;
+    } else if ((0, import_is.isURLSearchParameters)(body)) {
+      this[INTERNALS].body = import_buffer.Buffer.from(body.toString());
+    } else if ((0, import_is.isBlob)(body)) {
+    } else if (import_buffer.Buffer.isBuffer(body)) {
+    } else if (import_util.types.isAnyArrayBuffer(body)) {
+      this[INTERNALS].body = import_buffer.Buffer.from(body);
+    } else if (ArrayBuffer.isView(body)) {
+      this[INTERNALS].body = import_buffer.Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+    } else if (body instanceof import_stream.Readable) {
+      this[INTERNALS].body = body;
+    } else if (body instanceof ReadableStream || body instanceof import_web.ReadableStream) {
+      this[INTERNALS].body = import_stream.Readable.fromWeb(body);
+    } else if (body instanceof import_esm_min.FormData) {
+      this[INTERNALS].body = (0, import_esm_min.formDataToBlob)(body);
+      this[INTERNALS].boundary = this[INTERNALS].body.type.split("=")[1];
+    } else if (typeof body === "string") {
+      this[INTERNALS].body = import_buffer.Buffer.from(body);
+    } else if (body instanceof import_url.URLSearchParams) {
+      this[INTERNALS].body = import_buffer.Buffer.from(body.toString());
+    } else {
+      console.warn(`Unknown body type "${typeof body}", try to parse the body to string!`);
+      this[INTERNALS].body = import_stream.Readable.from(typeof body.toString === "function" ? body.toString() : body);
+    }
+    if (import_buffer.Buffer.isBuffer(body)) {
+      this[INTERNALS].stream = import_stream.Readable.from(body);
+    } else if ((0, import_is.isBlob)(body)) {
+      this[INTERNALS].stream = import_stream.Readable.from(body.stream());
+    } else if (body instanceof import_stream.Readable) {
+      this[INTERNALS].stream = body;
+    }
+    if (body instanceof import_stream.Stream) {
+      body.on("error", (error_) => {
+        const error = error_ instanceof import_base.FetchBaseError ? error_ : new import_fetch_error.FetchError(`Invalid response body while trying to fetch ${this.url}: ${error_.message}`, "system", error_);
+        this[INTERNALS].error = error;
+      });
+    }
+  }
+  get body() {
+    return import_stream.Readable.toWeb(this[INTERNALS].stream);
+  }
+  get _stream() {
+    return this[INTERNALS].stream;
+  }
+  get bodyUsed() {
+    return this[INTERNALS].disturbed;
+  }
+  /**
+   * Decode response as ArrayBuffer
+   *
+   * @return  Promise
+   */
+  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 import_esm_min.FormData();
+      const parameters = new import_url.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
+   *
+   * @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();
+    return new import_file.Blob([buf], {
+      type: ct
+    });
+  }
+  /**
+   * Decode response as json
+   *
+   * @return  Promise
+   */
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+  /**
+   * Decode response as text
+   *
+   * @return  Promise
+   */
+  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 },
+  data: { get: (0, import_util.deprecate)(
+    () => {
+    },
+    "data doesn't exist, use json(), text(), arrayBuffer(), or body instead",
+    "https://github.com/node-fetch/node-fetch/issues/1000 (response)"
+  ) }
+});
+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 import_buffer.Buffer.alloc(0);
+  }
+  if (!(body instanceof import_stream.Stream)) {
+    return import_buffer.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 import_fetch_error.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 error_ = error instanceof import_base.FetchBaseError ? error : new import_fetch_error.FetchError(`Invalid response body while trying to fetch ${data.url}: ${error.message}`, "system", error);
+    throw error_;
+  }
+  if (body.readableEnded === true || body._readableState.ended === true) {
+    try {
+      if (accum.every((c) => typeof c === "string")) {
+        return import_buffer.Buffer.from(accum.join(""));
+      }
+      return import_buffer.Buffer.concat(accum, accumBytes);
+    } catch (error) {
+      throw new import_fetch_error.FetchError(`Could not create Buffer from response body for ${data.url}: ${error.message}`, "system", error);
+    }
+  } else {
+    throw new import_fetch_error.FetchError(`Premature close of server response while trying to fetch ${data.url}`);
+  }
+}
+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 import_stream.Stream && typeof body.getBoundary !== "function") {
+    p1 = new import_stream.PassThrough({ highWaterMark });
+    p2 = new import_stream.PassThrough({ highWaterMark });
+    body.pipe(p1);
+    body.pipe(p2);
+    instance[INTERNALS].stream = p1;
+    body = p2;
+  }
+  return body;
+};
+const extractContentType = (body, request) => {
+  if (body === null) {
+    return null;
+  }
+  if (typeof body === "string") {
+    return "text/plain;charset=UTF-8";
+  }
+  if ((0, import_is.isURLSearchParameters)(body)) {
+    return "application/x-www-form-urlencoded;charset=UTF-8";
+  }
+  if ((0, import_is.isBlob)(body)) {
+    return body.type || null;
+  }
+  if (import_buffer.Buffer.isBuffer(body) || import_util.types.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
+    return null;
+  }
+  if (body instanceof import_esm_min.FormData) {
+    return `multipart/form-data; boundary=${request[INTERNALS].boundary}`;
+  }
+  if (body instanceof import_stream.Stream) {
+    return null;
+  }
+  return "text/plain;charset=UTF-8";
+};
+const getTotalBytes = (request) => {
+  const { body } = request[INTERNALS];
+  if (body === null) {
+    return 0;
+  }
+  if ((0, import_is.isBlob)(body)) {
+    return body.size;
+  }
+  if (import_buffer.Buffer.isBuffer(body)) {
+    return body.length;
+  }
+  if (body && typeof body.getLengthSync === "function") {
+    const anyBody = body;
+    return anyBody.hasKnownLength && anyBody.hasKnownLength() ? anyBody.getLengthSync() : null;
+  }
+  return null;
+};
+const writeToStream = async (dest, { body }) => {
+  if (body === null) {
+    dest.end();
+  } else {
+    await pipeline(body, dest);
+  }
+};

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

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var abort_error_exports = {};
+__export(abort_error_exports, {
+  AbortError: () => AbortError
+});
+module.exports = __toCommonJS(abort_error_exports);
+var import_base = require("./base.js");
+class AbortError extends import_base.FetchBaseError {
+  constructor(message, type = "aborted") {
+    super(message, type);
+  }
+}

package/lib/cjs/errors/base.js

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var base_exports = {};
+__export(base_exports, {
+  FetchBaseError: () => FetchBaseError
+});
+module.exports = __toCommonJS(base_exports);
+class FetchBaseError extends Error {
+  type;
+  constructor(message, type) {
+    super(message);
+    Error.captureStackTrace(this, this.constructor);
+    this.type = type;
+  }
+  get name() {
+    return this.constructor.name;
+  }
+  get [Symbol.toStringTag]() {
+    return this.constructor.name;
+  }
+}

package/lib/cjs/errors/fetch-error.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fetch_error_exports = {};
+__export(fetch_error_exports, {
+  FetchError: () => FetchError
+});
+module.exports = __toCommonJS(fetch_error_exports);
+var import_base = require("./base.js");
+class FetchError extends import_base.FetchBaseError {
+  code;
+  errno;
+  erroredSysCall;
+  /**
+   * @param message Error message for human
+   * @param type Error type for machine
+   * @param systemError For Node.js system error
+   */
+  constructor(message, type, systemError) {
+    super(message, type);
+    if (systemError) {
+      this.code = this.errno = systemError.code;
+      this.erroredSysCall = systemError.syscall;
+    }
+  }
+}

package/lib/cjs/headers.js

@@ -0,0 +1,231 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var headers_exports = {};
+__export(headers_exports, {
+  default: () => Headers,
+  fromRawHeaders: () => fromRawHeaders
+});
+module.exports = __toCommonJS(headers_exports);
+var import_soup_3 = __toESM(require("@girs/soup-3.0"), 1);
+var import_url = require("@gjsify/deno-runtime/ext/url/00_url");
+var import_util = require("util");
+var http = __toESM(require("http"), 1);
+const validateHeaderName = http.validateHeaderName;
+const validateHeaderValue = http.validateHeaderValue;
+class Headers extends import_url.URLSearchParams {
+  /**
+   * Headers class
+   *
+   * @constructor
+   * @param init Response headers
+   */
+  constructor(init) {
+    let result = [];
+    if (init instanceof Headers) {
+      const raw = init.raw();
+      for (const [name, values] of Object.entries(raw)) {
+        result.push(...values.map((value) => [name, value]));
+      }
+    } else if (init == null) {
+    } else if (typeof init === "object" && !import_util.types.isBoxedPrimitive(init)) {
+      const method = init[Symbol.iterator];
+      if (method == null) {
+        result.push(...Object.entries(init));
+      } else {
+        if (typeof method !== "function") {
+          throw new TypeError("Header pairs must be iterable");
+        }
+        result = [...init].map((pair) => {
+          if (typeof pair !== "object" || import_util.types.isBoxedPrimitive(pair)) {
+            throw new TypeError("Each header pair must be an iterable object");
+          }
+          return [...pair];
+        }).map((pair) => {
+          if (pair.length !== 2) {
+            throw new TypeError("Each header pair must be a name/value tuple");
+          }
+          return [...pair];
+        });
+      }
+    } else {
+      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 import_url.URLSearchParams.prototype[p].call(
+                target,
+                String(name).toLowerCase(),
+                String(value)
+              );
+            };
+          case "delete":
+          case "has":
+          case "getAll":
+            return (name) => {
+              validateHeaderName(name);
+              return import_url.URLSearchParams.prototype[p].call(
+                target,
+                String(name).toLowerCase()
+              );
+            };
+          case "keys":
+            return () => {
+              target.sort();
+              return new Set(import_url.URLSearchParams.prototype.keys.call(target)).keys();
+            };
+          default:
+            return Reflect.get(target, p, receiver);
+        }
+      }
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return this.constructor.name;
+  }
+  toString() {
+    return Object.prototype.toString.call(this);
+  }
+  _appendToSoupMessage(message, type = import_soup_3.default.MessageHeadersType.REQUEST) {
+    const soupHeaders = message ? message.get_request_headers() : new import_soup_3.default.MessageHeaders(type);
+    for (const header in this.entries()) {
+      soupHeaders.append(header, this.get(header));
+    }
+    return soupHeaders;
+  }
+  static _newFromSoupMessage(message, type = import_soup_3.default.MessageHeadersType.RESPONSE) {
+    let soupHeaders;
+    const headers = new Headers();
+    if (type === import_soup_3.default.MessageHeadersType.RESPONSE) {
+      soupHeaders = message.get_response_headers();
+    } else if (type === import_soup_3.default.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;
+  }
+  get(name) {
+    const values = this.getAll(name);
+    if (values.length === 0) {
+      return null;
+    }
+    let value = values.join(", ");
+    if (/^content-encoding$/i.test(name)) {
+      value = value.toLowerCase();
+    }
+    return value;
+  }
+  forEach(callback, thisArg = void 0) {
+    for (const name of this.keys()) {
+      Reflect.apply(callback, thisArg, [this.get(name), name, this]);
+    }
+  }
+  *values() {
+    for (const name of this.keys()) {
+      yield this.get(name);
+    }
+  }
+  /**
+   * 
+   */
+  *entries() {
+    for (const name of this.keys()) {
+      yield [name, this.get(name)];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  /**
+   * Node-fetch non-spec method
+   * returning all headers and their values as array
+   */
+  raw() {
+    return [...this.keys()].reduce((result, key) => {
+      result[key] = this.getAll(key);
+      return result;
+    }, {});
+  }
+  /**
+   * For better console.log(headers) and also to convert Headers into Node.js Request compatible format
+   */
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return [...this.keys()].reduce((result, key) => {
+      const values = this.getAll(key);
+      if (key === "host") {
+        result[key] = values[0];
+      } else {
+        result[key] = values.length > 1 ? values : values[0];
+      }
+      return result;
+    }, {});
+  }
+}
+Object.defineProperties(
+  Headers.prototype,
+  ["get", "entries", "forEach", "values"].reduce((result, property) => {
+    result[property] = { enumerable: true };
+    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;
+      }
+    })
+  );
+}