@gjsify/fetch 0.0.2

package/lib/cjs/index.js

@@ -0,0 +1,246 @@
+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 src_exports = {};
+__export(src_exports, {
+  AbortError: () => import_abort_error.AbortError,
+  Blob: () => import_blob_from.Blob,
+  FetchError: () => import_fetch_error.FetchError,
+  File: () => import_blob_from.File,
+  FormData: () => import_esm_min.FormData,
+  Headers: () => import_headers.default,
+  Request: () => import_request.default,
+  Response: () => import_response.default,
+  blobFrom: () => import_blob_from.blobFrom,
+  blobFromSync: () => import_blob_from.blobFromSync,
+  default: () => fetch,
+  fileFrom: () => import_blob_from.fileFrom,
+  fileFromSync: () => import_blob_from.fileFromSync,
+  isRedirect: () => import_is_redirect.isRedirect
+});
+module.exports = __toCommonJS(src_exports);
+var import_soup_3 = __toESM(require("@girs/soup-3.0"), 1);
+var import_request = __toESM(require("./request.js"), 1);
+var import_zlib = __toESM(require("zlib"), 1);
+var import_stream = __toESM(require("stream"), 1);
+var import_data_uri_to_buffer = __toESM(require("data-uri-to-buffer"), 1);
+var import_body = require("./body.js");
+var import_response = __toESM(require("./response.js"), 1);
+var import_headers = __toESM(require("./headers.js"), 1);
+var import_request2 = require("./request.js");
+var import_fetch_error = require("./errors/fetch-error.js");
+var import_abort_error = require("./errors/abort-error.js");
+var import_is_redirect = require("./utils/is-redirect.js");
+var import_esm_min = require("formdata-polyfill/esm.min.js");
+var import_is = require("./utils/is.js");
+var import_referrer = require("./utils/referrer.js");
+var import_blob_from = require("./utils/blob-from.js");
+var import_url = require("@gjsify/deno-runtime/ext/url/00_url");
+const supportedSchemas = /* @__PURE__ */ new Set(["data:", "http:", "https:"]);
+async function fetch(url, init = {}) {
+  return new Promise(async (resolve, reject) => {
+    const request = new import_request.default(url, init);
+    const { parsedURL, options } = (0, import_request2.getSoupRequestOptions)(request);
+    if (!supportedSchemas.has(parsedURL.protocol)) {
+      throw new TypeError(`@gjsify/fetch cannot load ${url}. URL scheme "${parsedURL.protocol.replace(/:$/, "")}" is not supported.`);
+    }
+    if (parsedURL.protocol === "data:") {
+      const data = (0, import_data_uri_to_buffer.default)(request.url);
+      const response2 = new import_response.default(data, { headers: { "Content-Type": data.typeFull } });
+      resolve(response2);
+      return;
+    }
+    const { signal } = request;
+    let response = null;
+    const abort = () => {
+      const error = new import_abort_error.AbortError("The operation was aborted.");
+      reject(error);
+      if (request.body && request.body instanceof import_stream.default.Readable) {
+        request.body.destroy(error);
+      }
+      if (!response || !response.body) {
+        return;
+      }
+      response.body.emit("error", error);
+    };
+    if (signal && signal.aborted) {
+      abort();
+      return;
+    }
+    const abortAndFinalize = () => {
+      abort();
+      finalize();
+    };
+    let readable;
+    let cancellable;
+    try {
+      const sendRes = await request._send(options);
+      readable = sendRes.readable;
+      cancellable = sendRes.cancellable;
+    } catch (error) {
+      reject(error);
+    }
+    if (signal) {
+      signal.addEventListener("abort", abortAndFinalize);
+    }
+    const cancelledSignalId = cancellable.connect("cancelled", () => {
+      abortAndFinalize();
+    });
+    const finalize = () => {
+      cancellable.cancel();
+      if (signal) {
+        signal.removeEventListener("abort", abortAndFinalize);
+      }
+      cancellable.disconnect(cancelledSignalId);
+    };
+    const message = request._message;
+    readable.on("error", (error) => {
+      reject(new import_fetch_error.FetchError(`request to ${request.url} failed, reason: ${error.message}`, "system", error));
+      finalize();
+    });
+    message.connect("finished", (message2) => {
+      const headers = import_headers.default._newFromSoupMessage(request._message, import_soup_3.default.MessageHeadersType.RESPONSE);
+      const statusCode = message2.status_code;
+      const statusMessage = message2.get_reason_phrase();
+      if ((0, import_is_redirect.isRedirect)(statusCode)) {
+        const location = headers.get("Location");
+        let locationURL = null;
+        try {
+          locationURL = location === null ? null : new import_url.URL(location, request.url);
+        } catch {
+          if (request.redirect !== "manual") {
+            reject(new import_fetch_error.FetchError(`uri requested responds with an invalid redirect URL: ${location}`, "invalid-redirect"));
+            finalize();
+            return;
+          }
+        }
+        switch (request.redirect) {
+          case "error":
+            reject(new import_fetch_error.FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, "no-redirect"));
+            finalize();
+            return;
+          case "manual":
+            break;
+          case "follow": {
+            if (locationURL === null) {
+              break;
+            }
+            if (request.counter >= request.follow) {
+              reject(new import_fetch_error.FetchError(`maximum redirect reached at: ${request.url}`, "max-redirect"));
+              finalize();
+              return;
+            }
+            const requestOptions = {
+              headers: new import_headers.default(request.headers),
+              follow: request.follow,
+              counter: request.counter + 1,
+              agent: request.agent,
+              compress: request.compress,
+              method: request.method,
+              body: (0, import_body.clone)(request),
+              signal: request.signal,
+              size: request.size,
+              referrer: request.referrer,
+              referrerPolicy: request.referrerPolicy
+            };
+            if (!(0, import_is.isDomainOrSubdomain)(request.url, locationURL) || !(0, import_is.isSameProtocol)(request.url, locationURL)) {
+              for (const name of ["authorization", "www-authenticate", "cookie", "cookie2"]) {
+                requestOptions.headers.delete(name);
+              }
+            }
+            if (statusCode !== 303 && request.body && init.body instanceof import_stream.default.Readable) {
+              reject(new import_fetch_error.FetchError("Cannot follow redirect with body being a readable stream", "unsupported-redirect"));
+              finalize();
+              return;
+            }
+            if (statusCode === 303 || (statusCode === 301 || statusCode === 302) && request.method === "POST") {
+              requestOptions.method = "GET";
+              requestOptions.body = void 0;
+              requestOptions.headers.delete("content-length");
+            }
+            const responseReferrerPolicy = (0, import_referrer.parseReferrerPolicyFromHeader)(headers);
+            if (responseReferrerPolicy) {
+              requestOptions.referrerPolicy = responseReferrerPolicy;
+            }
+            resolve(fetch(new import_request.default(locationURL, requestOptions)));
+            finalize();
+            return;
+          }
+          default:
+            return reject(new TypeError(`Redirect option '${request.redirect}' is not a valid value of RequestRedirect`));
+        }
+      }
+      let body = (0, import_stream.pipeline)(response_, new import_stream.PassThrough(), (error) => {
+        if (error) {
+          reject(error);
+        }
+      });
+      const responseOptions = {
+        url: request.url,
+        status: statusCode,
+        statusText: statusMessage,
+        headers,
+        size: request.size,
+        counter: request.counter,
+        highWaterMark: request.highWaterMark
+      };
+      const codings = headers.get("Content-Encoding");
+      if (!request.compress || request.method === "HEAD" || codings === null || statusCode === 204 || statusCode === 304) {
+        response = new import_response.default(body, responseOptions);
+        resolve(response);
+        return;
+      }
+      const zlibOptions = {
+        flush: import_zlib.default.Z_SYNC_FLUSH,
+        finishFlush: import_zlib.default.Z_SYNC_FLUSH
+      };
+      if (codings === "gzip" || codings === "x-gzip") {
+        body = (0, import_stream.pipeline)(body, import_zlib.default.createGunzip(zlibOptions), (error) => {
+          if (error) {
+            reject(error);
+          }
+        });
+        response = new import_response.default(body, responseOptions);
+        resolve(response);
+        return;
+      }
+      if (codings === "br") {
+        body = (0, import_stream.pipeline)(body, import_zlib.default.createBrotliDecompress(), (error) => {
+          if (error) {
+            reject(error);
+          }
+        });
+        response = new import_response.default(body, responseOptions);
+        resolve(response);
+        return;
+      }
+      response = new import_response.default(body, responseOptions);
+      resolve(response);
+    });
+    (0, import_body.writeToStream)(inputStream, request).catch(reject);
+  });
+}

package/lib/cjs/request.js

@@ -0,0 +1,306 @@
+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 request_exports = {};
+__export(request_exports, {
+  Request: () => Request,
+  default: () => request_default,
+  getSoupRequestOptions: () => getSoupRequestOptions
+});
+module.exports = __toCommonJS(request_exports);
+var import_gjs = require("@girs/gjs");
+var import_gio_2 = require("@girs/gio-2.0");
+var import_glib_2 = __toESM(require("@girs/glib-2.0"), 1);
+var import_soup_3 = __toESM(require("@girs/soup-3.0"), 1);
+var import_gio_22 = __toESM(require("@girs/gio-2.0"), 1);
+var SoupExt = __toESM(require("@gjsify/soup-3.0"), 1);
+var import_url = require("@gjsify/deno-runtime/ext/url/00_url");
+var import_headers = __toESM(require("./headers.js"), 1);
+var import_body = __toESM(require("./body.js"), 1);
+var import_is = require("./utils/is.js");
+var import_referrer = require("./utils/referrer.js");
+const INTERNALS = Symbol("Request internals");
+const isRequest = (obj) => {
+  return typeof obj === "object" && typeof obj.url === "string";
+};
+class Request extends import_body.default {
+  /** Returns the cache mode associated with request, which is a string indicating how the request will interact with the browser's cache when fetching. */
+  cache;
+  /** Returns the credentials mode associated with request, which is a string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. */
+  credentials;
+  /** Returns the kind of resource requested by request, e.g., "document" or "script". */
+  destination;
+  /** Returns a Headers object consisting of the headers associated with request. Note that headers added in the network layer by the user agent will not be accounted for in this object, e.g., the "Host" header. */
+  get headers() {
+    return this[INTERNALS].headers;
+  }
+  /** Returns request's subresource integrity metadata, which is a cryptographic hash of the resource being fetched. Its value consists of multiple hashes separated by whitespace. [SRI] */
+  integrity;
+  /** Returns a boolean indicating whether or not request can outlive the global in which it was created. */
+  keepalive;
+  /** Returns request's HTTP method, which is "GET" by default. */
+  get method() {
+    return this[INTERNALS].method;
+  }
+  /** Returns the mode associated with request, which is a string indicating whether the request will use CORS, or will be restricted to same-origin URLs. */
+  mode;
+  /** Returns the redirect mode associated with request, which is a string indicating how redirects for the request will be handled during fetching. A request will follow redirects by default. */
+  get redirect() {
+    return this[INTERNALS].redirect;
+  }
+  /**
+   * Returns the referrer of request.
+   * Its value can be a same-origin URL if explicitly set in init, the empty string to indicate no referrer, and "about:client" when defaulting to the global's default.
+   * This is used during fetching to determine the value of the `Referer` header of the request being made.
+   * @see https://fetch.spec.whatwg.org/#dom-request-referrer
+   **/
+  get referrer() {
+    if (this[INTERNALS].referrer === "no-referrer") {
+      return "";
+    }
+    if (this[INTERNALS].referrer === "client") {
+      return "about:client";
+    }
+    if (this[INTERNALS].referrer) {
+      return this[INTERNALS].referrer.toString();
+    }
+    return void 0;
+  }
+  /** Returns the referrer policy associated with request. This is used during fetching to compute the value of the request's referrer. */
+  get referrerPolicy() {
+    return this[INTERNALS].referrerPolicy;
+  }
+  set referrerPolicy(referrerPolicy) {
+    this[INTERNALS].referrerPolicy = (0, import_referrer.validateReferrerPolicy)(referrerPolicy);
+  }
+  /** Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler. */
+  get signal() {
+    return this[INTERNALS].signal;
+  }
+  /** Returns the URL of request as a string. */
+  get url() {
+    return this[INTERNALS].parsedURL.toString();
+  }
+  get _uri() {
+    return import_glib_2.default.Uri.parse(this.url, import_glib_2.default.UriFlags.NONE);
+  }
+  get _session() {
+    return this[INTERNALS].session;
+  }
+  get _message() {
+    return this[INTERNALS].message;
+  }
+  get _inputStream() {
+    return this[INTERNALS].inputStream;
+  }
+  get [Symbol.toStringTag]() {
+    return "Request";
+  }
+  [INTERNALS];
+  // Node-fetch-only options
+  follow;
+  compress = false;
+  counter = 0;
+  agent = "";
+  highWaterMark = 16384;
+  insecureHTTPParser = false;
+  constructor(input, init) {
+    let parsedURL;
+    let requestObj = {};
+    if (isRequest(input)) {
+      parsedURL = new import_url.URL(input.url);
+      requestObj = input;
+    } else {
+      parsedURL = new import_url.URL(input);
+    }
+    if (parsedURL.username !== "" || parsedURL.password !== "") {
+      throw new TypeError(`${parsedURL} is an url with embedded credentials.`);
+    }
+    let method = init.method || requestObj.method || "GET";
+    if (/^(delete|get|head|options|post|put)$/i.test(method)) {
+      method = method.toUpperCase();
+    }
+    if ((init.body != null || isRequest(input) && input.body !== null) && (method === "GET" || method === "HEAD")) {
+      throw new TypeError("Request with GET/HEAD method cannot have body");
+    }
+    const inputBody = init.body ? init.body : isRequest(input) && input.body !== null ? (0, import_body.clone)(input) : null;
+    super(inputBody, {
+      size: init.size || init.size || 0
+    });
+    const headers = new import_headers.default(init.headers || input.headers || {});
+    if (inputBody !== null && !headers.has("Content-Type")) {
+      const contentType = (0, import_body.extractContentType)(inputBody, this);
+      if (contentType) {
+        headers.set("Content-Type", contentType);
+      }
+    }
+    let signal = isRequest(input) ? input.signal : null;
+    if ("signal" in init) {
+      signal = init.signal;
+    }
+    if (signal != null && !(0, import_is.isAbortSignal)(signal)) {
+      throw new TypeError("Expected signal to be an instanceof AbortSignal or EventTarget");
+    }
+    let referrer = init.referrer == null ? input.referrer : init.referrer;
+    if (referrer === "") {
+      referrer = "no-referrer";
+    } else if (referrer) {
+      const parsedReferrer = new import_url.URL(referrer);
+      referrer = /^about:(\/\/)?client$/.test(parsedReferrer.toString()) ? "client" : parsedReferrer;
+    } else {
+      referrer = void 0;
+    }
+    const session = SoupExt.ExtSession.new();
+    const message = new import_soup_3.default.Message({
+      method,
+      uri: this._uri
+    });
+    this[INTERNALS] = {
+      method,
+      redirect: init.redirect || input.redirect || "follow",
+      headers,
+      parsedURL,
+      signal,
+      referrer,
+      referrerPolicy: "",
+      session,
+      message
+    };
+    this.follow = init.follow === void 0 ? input.follow === void 0 ? 20 : input.follow : init.follow;
+    this.compress = init.compress === void 0 ? input.compress === void 0 ? true : input.compress : init.compress;
+    this.counter = init.counter || input.counter || 0;
+    this.agent = init.agent || input.agent;
+    this.highWaterMark = init.highWaterMark || input.highWaterMark || 16384;
+    this.insecureHTTPParser = init.insecureHTTPParser || input.insecureHTTPParser || false;
+    this.referrerPolicy = init.referrerPolicy || input.referrerPolicy || "";
+  }
+  /**
+   * Custom send method using Soup, used in fetch to send the request
+   * @param options 
+   * @returns 
+   */
+  async _send(options) {
+    options.headers._appendToSoupMessage(this._message);
+    const cancellable = new import_gio_22.default.Cancellable();
+    this[INTERNALS].inputStream = await this._session.sendAsync(this._message, import_glib_2.default.PRIORITY_DEFAULT, cancellable);
+    this[INTERNALS].readable = this[INTERNALS].inputStream.toReadable({});
+    return {
+      inputStream: this[INTERNALS].inputStream,
+      readable: this[INTERNALS].readable,
+      cancellable
+    };
+  }
+  /**
+   * Clone this request
+   */
+  clone() {
+    return new Request(this);
+  }
+  async arrayBuffer() {
+    return super.arrayBuffer();
+  }
+  async blob() {
+    return super.blob();
+  }
+  async formData() {
+    return super.formData();
+  }
+  async json() {
+    return super.json();
+  }
+  async text() {
+    return super.text();
+  }
+}
+Object.defineProperties(Request.prototype, {
+  method: { enumerable: true },
+  url: { enumerable: true },
+  headers: { enumerable: true },
+  redirect: { enumerable: true },
+  clone: { enumerable: true },
+  signal: { enumerable: true },
+  referrer: { enumerable: true },
+  referrerPolicy: { enumerable: true }
+});
+var request_default = Request;
+const getSoupRequestOptions = (request) => {
+  const { parsedURL } = request[INTERNALS];
+  const headers = new import_headers.default(request[INTERNALS].headers);
+  if (!headers.has("Accept")) {
+    headers.set("Accept", "*/*");
+  }
+  let contentLengthValue = null;
+  if (request.body === null && /^(post|put)$/i.test(request.method)) {
+    contentLengthValue = "0";
+  }
+  if (request.body !== null) {
+    const totalBytes = (0, import_body.getTotalBytes)(request);
+    if (typeof totalBytes === "number" && !Number.isNaN(totalBytes)) {
+      contentLengthValue = String(totalBytes);
+    }
+  }
+  if (contentLengthValue) {
+    headers.set("Content-Length", contentLengthValue);
+  }
+  if (request.referrerPolicy === "") {
+    request.referrerPolicy = import_referrer.DEFAULT_REFERRER_POLICY;
+  }
+  if (request.referrer && request.referrer !== "no-referrer") {
+    request[INTERNALS].referrer = (0, import_referrer.determineRequestsReferrer)(request);
+  } else {
+    request[INTERNALS].referrer = "no-referrer";
+  }
+  if (request[INTERNALS].referrer instanceof import_url.URL) {
+    headers.set("Referer", request.referrer);
+  }
+  if (!headers.has("User-Agent")) {
+    headers.set("User-Agent", "node-fetch");
+  }
+  if (request.compress && !headers.has("Accept-Encoding")) {
+    headers.set("Accept-Encoding", "gzip, deflate, br");
+  }
+  let { agent } = request;
+  if (typeof agent === "function") {
+    agent = agent(parsedURL);
+  }
+  if (!headers.has("Connection") && !agent) {
+    headers.set("Connection", "close");
+  }
+  const options = {
+    // Overwrite search to retain trailing ? (issue #776)
+    // path: parsedURL.pathname + search,
+    // The following options are not expressed in the URL
+    // method: request.method,
+    headers
+    // insecureHTTPParser: request.insecureHTTPParser,
+    // agent
+  };
+  return {
+    parsedURL,
+    options
+  };
+};