@gjsify/fetch 0.0.2

package/lib/cjs/response.js

@@ -0,0 +1,162 @@
+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 response_exports = {};
+__export(response_exports, {
+  Response: () => Response,
+  default: () => response_default
+});
+module.exports = __toCommonJS(response_exports);
+var import_glib_2 = __toESM(require("@girs/glib-2.0"), 1);
+var import_gio_2 = __toESM(require("@girs/gio-2.0"), 1);
+var import_headers = __toESM(require("./headers.js"), 1);
+var import_body = __toESM(require("./body.js"), 1);
+var import_is_redirect = require("./utils/is-redirect.js");
+var import_url = require("@gjsify/deno-runtime/ext/url/00_url");
+const INTERNALS = Symbol("Response internals");
+class Response extends import_body.default {
+  [INTERNALS];
+  _inputStream = null;
+  constructor(body = null, options = {}) {
+    super(body, options);
+    const status = options.status != null ? options.status : 200;
+    const headers = new import_headers.default(options.headers);
+    if (body !== null && !headers.has("Content-Type")) {
+      const contentType = (0, import_body.extractContentType)(body, this);
+      if (contentType) {
+        headers.append("Content-Type", contentType);
+      }
+    }
+    this[INTERNALS] = {
+      type: "default",
+      url: options.url,
+      status,
+      statusText: options.statusText || "",
+      headers,
+      counter: options.counter,
+      highWaterMark: options.highWaterMark
+    };
+  }
+  get type() {
+    return this[INTERNALS].type;
+  }
+  get url() {
+    return this[INTERNALS].url || "";
+  }
+  get status() {
+    return this[INTERNALS].status;
+  }
+  /**
+   * Convenience property representing if the request ended normally
+   */
+  get ok() {
+    return this[INTERNALS].status >= 200 && this[INTERNALS].status < 300;
+  }
+  get redirected() {
+    return this[INTERNALS].counter > 0;
+  }
+  get statusText() {
+    return this[INTERNALS].statusText;
+  }
+  get headers() {
+    return this[INTERNALS].headers;
+  }
+  get highWaterMark() {
+    return this[INTERNALS].highWaterMark;
+  }
+  /**
+   * Clone this response
+   *
+   * @return  Response
+   */
+  // @ts-ignore
+  clone() {
+    return new Response((0, import_body.clone)(this, this.highWaterMark), {
+      type: this.type,
+      url: this.url,
+      status: this.status,
+      statusText: this.statusText,
+      headers: this.headers,
+      ok: this.ok,
+      redirected: this.redirected,
+      size: this.size,
+      highWaterMark: this.highWaterMark
+    });
+  }
+  /**
+   * @param url The URL that the new response is to originate from.
+   * @param status An optional status code for the response (e.g., 302.)
+   * @returns A Response object.
+   */
+  static redirect(url, status = 302) {
+    if (!(0, import_is_redirect.isRedirect)(status)) {
+      throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
+    }
+    return new Response(null, {
+      headers: {
+        location: new import_url.URL(url).toString()
+      },
+      status
+    });
+  }
+  static error() {
+    const response = new Response(null, { status: 0, statusText: "" });
+    response[INTERNALS].type = "error";
+    return response;
+  }
+  get [Symbol.toStringTag]() {
+    return "Response";
+  }
+  async text() {
+    if (!this._inputStream) {
+      return super.text();
+    }
+    const outputStream = import_gio_2.default.MemoryOutputStream.new_resizable();
+    await new Promise((resolve, reject) => {
+      outputStream.splice_async(this._inputStream, import_gio_2.default.OutputStreamSpliceFlags.CLOSE_TARGET | import_gio_2.default.OutputStreamSpliceFlags.CLOSE_SOURCE, import_glib_2.default.PRIORITY_DEFAULT, null, (self, res) => {
+        try {
+          resolve(outputStream.splice_finish(res));
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+    const bytes = outputStream.steal_as_bytes();
+    return new TextDecoder().decode(bytes.toArray());
+  }
+}
+Object.defineProperties(Response.prototype, {
+  type: { enumerable: true },
+  url: { enumerable: true },
+  status: { enumerable: true },
+  ok: { enumerable: true },
+  redirected: { enumerable: true },
+  statusText: { enumerable: true },
+  headers: { enumerable: true },
+  clone: { enumerable: true }
+});
+var response_default = Response;

package/lib/cjs/types/index.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("./system-error.js"), module.exports);

package/lib/cjs/types/system-error.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 system_error_exports = {};
+module.exports = __toCommonJS(system_error_exports);
+;

package/lib/cjs/utils/blob-from.js

@@ -0,0 +1,124 @@
+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 blob_from_exports = {};
+__export(blob_from_exports, {
+  Blob: () => import_file.Blob,
+  File: () => import_file.File,
+  blobFrom: () => blobFrom,
+  blobFromSync: () => blobFromSync,
+  createTemporaryBlob: () => createTemporaryBlob,
+  createTemporaryFile: () => createTemporaryFile,
+  default: () => blob_from_default,
+  fileFrom: () => fileFrom,
+  fileFromSync: () => fileFromSync
+});
+module.exports = __toCommonJS(blob_from_exports);
+var import_dom_exception = require("@gjsify/deno-runtime/ext/web/01_dom_exception");
+var import_file = require("@gjsify/deno-runtime/ext/web/09_file");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_node_os = require("node:os");
+var import_node_process = __toESM(require("node:process"), 1);
+const { stat, mkdtemp } = import_node_fs.promises;
+let i = 0, tempDir, registry;
+const blobFromSync = (path, type) => fromBlob((0, import_node_fs.statSync)(path), path, type);
+const blobFrom = (path, type) => stat(path).then((stat2) => fromBlob(stat2, path, type));
+const fileFrom = (path, type) => stat(path).then((stat2) => fromFile(stat2, path, type));
+const fileFromSync = (path, type) => fromFile((0, import_node_fs.statSync)(path), path, type);
+const fromBlob = (stat2, path, type = "") => new import_file.Blob([new BlobDataItem({
+  path,
+  size: stat2.size,
+  lastModified: stat2.mtimeMs,
+  start: 0
+})], { type });
+const fromFile = (stat2, path, type = "") => new import_file.File([new BlobDataItem({
+  path,
+  size: stat2.size,
+  lastModified: stat2.mtimeMs,
+  start: 0
+})], (0, import_node_path.basename)(path), { type, lastModified: stat2.mtimeMs });
+const createTemporaryBlob = async (data, { signal, type } = {}) => {
+  registry = registry || new FinalizationRegistry(import_node_fs.promises.unlink);
+  tempDir = tempDir || await mkdtemp((0, import_node_fs.realpathSync)((0, import_node_os.tmpdir)()) + import_node_path.sep);
+  const id = `${i++}`;
+  const destination = (0, import_node_path.join)(tempDir, id);
+  if (data instanceof ArrayBuffer)
+    data = new Uint8Array(data);
+  await import_node_fs.promises.writeFile(destination, data, { signal });
+  const blob = await blobFrom(destination, type);
+  registry.register(blob, destination);
+  return blob;
+};
+const createTemporaryFile = async (data, name, opts) => {
+  const blob = await createTemporaryBlob(data);
+  return new import_file.File([blob], name, opts);
+};
+class BlobDataItem {
+  #path;
+  #start;
+  size;
+  lastModified;
+  originalSize;
+  constructor(options) {
+    this.#path = options.path;
+    this.#start = options.start;
+    this.size = options.size;
+    this.lastModified = options.lastModified;
+    this.originalSize = options.originalSize === void 0 ? options.size : options.originalSize;
+  }
+  /**
+   * Slicing arguments is first validated and formatted
+   * to not be out of range by Blob.prototype.slice
+   */
+  slice(start, end) {
+    return new BlobDataItem({
+      path: this.#path,
+      lastModified: this.lastModified,
+      originalSize: this.originalSize,
+      size: end - start,
+      start: this.#start + start
+    });
+  }
+  async *stream() {
+    const { mtimeMs, size } = await stat(this.#path);
+    if (mtimeMs > this.lastModified || this.originalSize !== size) {
+      throw new import_dom_exception.DOMException("The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.", "NotReadableError");
+    }
+    yield* (0, import_node_fs.createReadStream)(this.#path, {
+      start: this.#start,
+      end: this.#start + this.size - 1
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "Blob";
+  }
+}
+import_node_process.default.once("exit", () => {
+  tempDir && (0, import_node_fs.rmdirSync)(tempDir, { recursive: true });
+});
+var blob_from_default = blobFromSync;

package/lib/cjs/utils/get-search.js

@@ -0,0 +1,30 @@
+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 get_search_exports = {};
+__export(get_search_exports, {
+  getSearch: () => getSearch
+});
+module.exports = __toCommonJS(get_search_exports);
+const getSearch = (parsedURL) => {
+  if (parsedURL.search) {
+    return parsedURL.search;
+  }
+  const lastOffset = parsedURL.href.length - 1;
+  const hash = parsedURL.hash || (parsedURL.href[lastOffset] === "#" ? "#" : "");
+  return parsedURL.href[lastOffset - hash.length] === "?" ? "?" : "";
+};

package/lib/cjs/utils/is-redirect.js

@@ -0,0 +1,26 @@
+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 is_redirect_exports = {};
+__export(is_redirect_exports, {
+  isRedirect: () => isRedirect
+});
+module.exports = __toCommonJS(is_redirect_exports);
+const redirectStatus = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+const isRedirect = (code) => {
+  return redirectStatus.has(code);
+};

package/lib/cjs/utils/is.js

@@ -0,0 +1,47 @@
+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 is_exports = {};
+__export(is_exports, {
+  isAbortSignal: () => isAbortSignal,
+  isBlob: () => isBlob,
+  isDomainOrSubdomain: () => isDomainOrSubdomain,
+  isSameProtocol: () => isSameProtocol,
+  isURLSearchParameters: () => isURLSearchParameters
+});
+module.exports = __toCommonJS(is_exports);
+var import_url = require("@gjsify/deno-runtime/ext/url/00_url");
+const NAME = Symbol.toStringTag;
+const isURLSearchParameters = (object) => {
+  return typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && typeof object.sort === "function" && object[NAME] === "URLSearchParams";
+};
+const isBlob = (value) => {
+  return value && typeof value === "object" && typeof value.arrayBuffer === "function" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.constructor === "function" && /^(Blob|File)$/.test(value[NAME]);
+};
+const isAbortSignal = (object) => {
+  return typeof object === "object" && (object[NAME] === "AbortSignal" || object[NAME] === "EventTarget");
+};
+const isDomainOrSubdomain = (destination, original) => {
+  const orig = new import_url.URL(original).hostname;
+  const dest = new import_url.URL(destination).hostname;
+  return orig === dest || orig.endsWith(`.${dest}`);
+};
+const isSameProtocol = (destination, original) => {
+  const orig = new import_url.URL(original).protocol;
+  const dest = new import_url.URL(destination).protocol;
+  return orig === dest;
+};