@gjsify/fetch 0.0.4 → 0.1.0

package/lib/cjs/errors/base.js

@@ -1,17 +0,0 @@
-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;
-  }
-}
-export {
-  FetchBaseError
-};

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

@@ -1,21 +0,0 @@
-import { FetchBaseError } from "./base.js";
-class FetchError extends 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;
-    }
-  }
-}
-export {
-  FetchError
-};

package/lib/cjs/headers.js

@@ -1,202 +0,0 @@
-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
-   */
-  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" && !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" || 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 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;
-  }
-  toString() {
-    return Object.prototype.toString.call(this);
-  }
-  _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;
-  }
-  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;
-  }
-  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;
-      }
-    })
-  );
-}
-export {
-  Headers as default,
-  fromRawHeaders
-};

package/lib/cjs/index.js

@@ -1,224 +0,0 @@
-import Soup from "@girs/soup-3.0";
-import Request from "./request.js";
-import zlib from "zlib";
-import Stream, { PassThrough, pipeline as pump } from "stream";
-import dataUriToBuffer from "data-uri-to-buffer";
-import { writeToStream, clone } from "./body.js";
-import Response from "./response.js";
-import Headers from "./headers.js";
-import { getSoupRequestOptions } from "./request.js";
-import { FetchError } from "./errors/fetch-error.js";
-import { AbortError } from "./errors/abort-error.js";
-import { isRedirect } from "./utils/is-redirect.js";
-import { FormData } from "formdata-polyfill/esm.min.js";
-import { isDomainOrSubdomain, isSameProtocol } from "./utils/is.js";
-import { parseReferrerPolicyFromHeader } from "./utils/referrer.js";
-import {
-  Blob,
-  File,
-  fileFromSync,
-  fileFrom,
-  blobFromSync,
-  blobFrom
-} from "./utils/blob-from.js";
-import { URL } from "@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 Request(url, init);
-    const { parsedURL, options } = 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 = dataUriToBuffer(request.url);
-      const response2 = new Response(data, { headers: { "Content-Type": data.typeFull } });
-      resolve(response2);
-      return;
-    }
-    const { signal } = request;
-    let response = null;
-    const abort = () => {
-      const error = new AbortError("The operation was aborted.");
-      reject(error);
-      if (request.body && request.body instanceof Stream.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 FetchError(`request to ${request.url} failed, reason: ${error.message}`, "system", error));
-      finalize();
-    });
-    message.connect("finished", (message2) => {
-      const headers = Headers._newFromSoupMessage(request._message, Soup.MessageHeadersType.RESPONSE);
-      const statusCode = message2.status_code;
-      const statusMessage = message2.get_reason_phrase();
-      if (isRedirect(statusCode)) {
-        const location = headers.get("Location");
-        let locationURL = null;
-        try {
-          locationURL = location === null ? null : new URL(location, request.url);
-        } catch {
-          if (request.redirect !== "manual") {
-            reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, "invalid-redirect"));
-            finalize();
-            return;
-          }
-        }
-        switch (request.redirect) {
-          case "error":
-            reject(new 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 FetchError(`maximum redirect reached at: ${request.url}`, "max-redirect"));
-              finalize();
-              return;
-            }
-            const requestOptions = {
-              headers: new Headers(request.headers),
-              follow: request.follow,
-              counter: request.counter + 1,
-              agent: request.agent,
-              compress: request.compress,
-              method: request.method,
-              body: clone(request),
-              signal: request.signal,
-              size: request.size,
-              referrer: request.referrer,
-              referrerPolicy: request.referrerPolicy
-            };
-            if (!isDomainOrSubdomain(request.url, locationURL) || !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 Stream.Readable) {
-              reject(new 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 = parseReferrerPolicyFromHeader(headers);
-            if (responseReferrerPolicy) {
-              requestOptions.referrerPolicy = responseReferrerPolicy;
-            }
-            resolve(fetch(new Request(locationURL, requestOptions)));
-            finalize();
-            return;
-          }
-          default:
-            return reject(new TypeError(`Redirect option '${request.redirect}' is not a valid value of RequestRedirect`));
-        }
-      }
-      let body = pump(response_, new 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 Response(body, responseOptions);
-        resolve(response);
-        return;
-      }
-      const zlibOptions = {
-        flush: zlib.Z_SYNC_FLUSH,
-        finishFlush: zlib.Z_SYNC_FLUSH
-      };
-      if (codings === "gzip" || codings === "x-gzip") {
-        body = pump(body, zlib.createGunzip(zlibOptions), (error) => {
-          if (error) {
-            reject(error);
-          }
-        });
-        response = new Response(body, responseOptions);
-        resolve(response);
-        return;
-      }
-      if (codings === "br") {
-        body = pump(body, zlib.createBrotliDecompress(), (error) => {
-          if (error) {
-            reject(error);
-          }
-        });
-        response = new Response(body, responseOptions);
-        resolve(response);
-        return;
-      }
-      response = new Response(body, responseOptions);
-      resolve(response);
-    });
-    writeToStream(inputStream, request).catch(reject);
-  });
-}
-export {
-  AbortError,
-  Blob,
-  FetchError,
-  File,
-  FormData,
-  Headers,
-  Request,
-  Response,
-  blobFrom,
-  blobFromSync,
-  fetch as default,
-  fileFrom,
-  fileFromSync,
-  isRedirect
-};