@gjsify/fetch 0.0.4 → 0.1.1

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

@@ -1,101 +1,5 @@
-import { DOMException } from "@gjsify/deno-runtime/ext/web/01_dom_exception";
-import { Blob, File } from "@gjsify/deno-runtime/ext/web/09_file";
-import {
-  realpathSync,
-  statSync,
-  rmdirSync,
-  createReadStream,
-  promises as fs
-} from "node:fs";
-import { basename, sep, join } from "node:path";
-import { tmpdir } from "node:os";
-import process from "node:process";
-const { stat, mkdtemp } = fs;
-let i = 0, tempDir, registry;
-const blobFromSync = (path, type) => fromBlob(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(statSync(path), path, type);
-const fromBlob = (stat2, path, type = "") => new Blob([new BlobDataItem({
-  path,
-  size: stat2.size,
-  lastModified: stat2.mtimeMs,
-  start: 0
-})], { type });
-const fromFile = (stat2, path, type = "") => new File([new BlobDataItem({
-  path,
-  size: stat2.size,
-  lastModified: stat2.mtimeMs,
-  start: 0
-})], basename(path), { type, lastModified: stat2.mtimeMs });
-const createTemporaryBlob = async (data, { signal, type } = {}) => {
-  registry = registry || new FinalizationRegistry(fs.unlink);
-  tempDir = tempDir || await mkdtemp(realpathSync(tmpdir()) + sep);
-  const id = `${i++}`;
-  const destination = join(tempDir, id);
-  if (data instanceof ArrayBuffer)
-    data = new Uint8Array(data);
-  await fs.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 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 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* createReadStream(this.#path, {
-      start: this.#start,
-      end: this.#start + this.size - 1
-    });
-  }
-  get [Symbol.toStringTag]() {
-    return "Blob";
-  }
-}
-process.once("exit", () => {
-  tempDir && rmdirSync(tempDir, { recursive: true });
-});
-var blob_from_default = blobFromSync;
+import { Blob, File } from "node:buffer";
 export {
   Blob,
-  File,
-  blobFrom,
-  blobFromSync,
-  createTemporaryBlob,
-  createTemporaryFile,
-  blob_from_default as default,
-  fileFrom,
-  fileFromSync
+  File
 };

package/lib/esm/utils/data-uri.js

@@ -0,0 +1,23 @@
+function parseDataUri(uri) {
+  const match = uri.match(/^data:([^,]*?)(;base64)?,(.*)$/s);
+  if (!match) {
+    throw new TypeError(`Invalid data URI: ${uri.slice(0, 50)}...`);
+  }
+  const typeFull = match[1] || "text/plain;charset=US-ASCII";
+  const isBase64 = !!match[2];
+  const data = match[3];
+  let buffer;
+  if (isBase64) {
+    const binaryString = atob(data);
+    buffer = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      buffer[i] = binaryString.charCodeAt(i);
+    }
+  } else {
+    buffer = new TextEncoder().encode(decodeURIComponent(data));
+  }
+  return { buffer, typeFull };
+}
+export {
+  parseDataUri
+};

package/lib/esm/utils/is.js

@@ -1,13 +1,17 @@
-import { URL } from "@gjsify/deno-runtime/ext/url/00_url";
+import { URL } from "@gjsify/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]);
+  if (!value || typeof value !== "object") return false;
+  const obj = value;
+  return typeof obj.arrayBuffer === "function" && typeof obj.type === "string" && typeof obj.stream === "function" && typeof obj.constructor === "function" && /^(Blob|File)$/.test(obj[NAME]);
 };
 const isAbortSignal = (object) => {
-  return typeof object === "object" && (object[NAME] === "AbortSignal" || object[NAME] === "EventTarget");
+  if (typeof object !== "object" || object === null) return false;
+  const obj = object;
+  return obj[NAME] === "AbortSignal" || obj[NAME] === "EventTarget";
 };
 const isDomainOrSubdomain = (destination, original) => {
   const orig = new URL(original).hostname;

package/lib/esm/utils/multipart-parser.js

@@ -1,5 +1,5 @@
 import { File } from "./blob-from.js";
-import { FormData } from "formdata-polyfill/esm.min.js";
+import { FormData } from "@gjsify/formdata";
 var S = /* @__PURE__ */ ((S2) => {
   S2[S2["START_BOUNDARY"] = 0] = "START_BOUNDARY";
   S2[S2["HEADER_FIELD_START"] = 1] = "HEADER_FIELD_START";
@@ -26,7 +26,7 @@ const COLON = 58;
 const A = 97;
 const Z = 122;
 const lower = (c) => c | 32;
-const noop = (...args) => {
+const noop = (..._args) => {
 };
 class MultipartParser {
   index = 0;
@@ -128,6 +128,7 @@ class MultipartParser {
           state = 2 /* HEADER_FIELD */;
           mark("onHeaderField");
           index = 0;
+        // falls through
         case 2 /* HEADER_FIELD */:
           if (c === CR) {
             clear("onHeaderField");
@@ -157,6 +158,7 @@ class MultipartParser {
           }
           mark("onHeaderValue");
           state = 4 /* HEADER_VALUE */;
+        // falls through
         case 4 /* HEADER_VALUE */:
           if (c === CR) {
             dataCallback("onHeaderValue", true);
@@ -180,6 +182,7 @@ class MultipartParser {
         case 7 /* PART_DATA_START */:
           state = 8 /* PART_DATA */;
           mark("onPartData");
+        // falls through
         case 8 /* PART_DATA */:
           previousIndex = index;
           if (index === 0) {

package/lib/esm/utils/referrer.js

@@ -1,21 +1,21 @@
-import { URL } from "@gjsify/deno-runtime/ext/url/00_url";
-import { isIP } from "net";
+import { URL } from "@gjsify/url";
+import { isIP } from "node:net";
 function stripURLForUseAsAReferrer(url, originOnly = false) {
   if (url == null || url === "no-referrer") {
     return "no-referrer";
   }
-  url = new URL(url);
-  if (/^(about|blob|data):$/.test(url.protocol)) {
+  const u = new URL(url);
+  if (/^(about|blob|data):$/.test(u.protocol)) {
     return "no-referrer";
   }
-  url.username = "";
-  url.password = "";
-  url.hash = "";
+  u.username = "";
+  u.password = "";
+  u.hash = "";
   if (originOnly) {
-    url.pathname = "";
-    url.search = "";
+    u.pathname = "";
+    u.search = "";
   }
-  return url;
+  return u;
 }
 const ReferrerPolicy = /* @__PURE__ */ new Set([
   "",

package/lib/esm/utils/soup-helpers.js

@@ -0,0 +1,22 @@
+import GLib from "@girs/glib-2.0";
+import { Readable } from "node:stream";
+import { inputStreamAsyncIterator } from "@gjsify/utils";
+async function soupSendAsync(session, msg, ioPriority = GLib.PRIORITY_DEFAULT, cancellable = null) {
+  return new Promise((resolve, reject) => {
+    session.send_async(msg, ioPriority, cancellable, (_self, asyncRes) => {
+      try {
+        const inputStream = session.send_finish(asyncRes);
+        resolve(inputStream);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+function inputStreamToReadable(inputStream, options = {}) {
+  return Readable.from(inputStreamAsyncIterator(inputStream), options);
+}
+export {
+  inputStreamToReadable,
+  soupSendAsync
+};

package/lib/headers.d.ts

@@ -0,0 +1,33 @@
+import Soup from '@girs/soup-3.0';
+declare const _headers: unique symbol;
+export default class Headers implements Iterable<[string, string]> {
+    [_headers]: Map<string, string[]>;
+    constructor(init?: HeadersInit | Headers | null);
+    append(name: string, value: string): void;
+    set(name: string, value: string): void;
+    delete(name: string): void;
+    has(name: string): boolean;
+    get(name: string): string | null;
+    getAll(name: string): string[];
+    getSetCookie(): string[];
+    forEach(callback: (value: string, name: string, parent: Headers) => void, thisArg?: unknown): void;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+    entries(): IterableIterator<[string, string]>;
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /**
+     * Node-fetch non-spec method: return all headers and their values as arrays.
+     */
+    raw(): Record<string, string[]>;
+    /**
+     * Append all headers to a Soup.Message for sending.
+     */
+    _appendToSoupMessage(message?: Soup.Message, type?: Soup.MessageHeadersType): Soup.MessageHeaders;
+    /**
+     * Create a Headers instance from a Soup.Message's headers.
+     */
+    static _newFromSoupMessage(message: Soup.Message, type?: Soup.MessageHeadersType): Headers;
+}
+export {};

package/lib/headers.js

@@ -0,0 +1,195 @@
+// SPDX-License-Identifier: MIT
+// Adapted from node-fetch (https://github.com/node-fetch/node-fetch/blob/main/src/headers.js)
+// Copyright (c) node-fetch contributors. MIT license.
+// Modifications: Standalone implementation using internal Map, libsoup integration
+import Soup from '@girs/soup-3.0';
+import { validateHeaderName, validateHeaderValue } from '@gjsify/http';
+const _headers = Symbol('Headers.headers');
+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));
+}
+export default class Headers {
+    [_headers];
+    constructor(init) {
+        this[_headers] = new Map();
+        if (init == null) {
+            return;
+        }
+        if (init instanceof Headers) {
+            for (const [name, values] of init[_headers]) {
+                this[_headers].set(name, [...values]);
+            }
+            return;
+        }
+        if (typeof init === 'object' && !isBoxedPrimitive(init)) {
+            const method = init[Symbol.iterator];
+            if (method == null) {
+                // Record<string, string>
+                for (const [name, value] of Object.entries(init)) {
+                    validateHeaderName(name);
+                    validateHeaderValue(name, String(value));
+                    this.append(name, String(value));
+                }
+            }
+            else {
+                if (typeof method !== 'function') {
+                    throw new TypeError('Header pairs must be iterable');
+                }
+                for (const pair of init) {
+                    if (typeof pair !== 'object' || isBoxedPrimitive(pair)) {
+                        throw new TypeError('Each header pair must be an iterable object');
+                    }
+                    const arr = [...pair];
+                    if (arr.length !== 2) {
+                        throw new TypeError('Each header pair must be a name/value tuple');
+                    }
+                    validateHeaderName(arr[0]);
+                    validateHeaderValue(arr[0], String(arr[1]));
+                    this.append(arr[0], String(arr[1]));
+                }
+            }
+        }
+        else {
+            throw new TypeError('Failed to construct \'Headers\': The provided value is not of type ' +
+                '\'(sequence<sequence<ByteString>> or record<ByteString, ByteString>)\'');
+        }
+    }
+    append(name, value) {
+        validateHeaderName(name);
+        validateHeaderValue(name, value);
+        const lowerName = String(name).toLowerCase();
+        const strValue = String(value);
+        const existing = this[_headers].get(lowerName);
+        if (existing) {
+            existing.push(strValue);
+        }
+        else {
+            this[_headers].set(lowerName, [strValue]);
+        }
+    }
+    set(name, value) {
+        validateHeaderName(name);
+        validateHeaderValue(name, value);
+        const lowerName = String(name).toLowerCase();
+        this[_headers].set(lowerName, [String(value)]);
+    }
+    delete(name) {
+        this[_headers].delete(String(name).toLowerCase());
+    }
+    has(name) {
+        return this[_headers].has(String(name).toLowerCase());
+    }
+    get(name) {
+        const values = this[_headers].get(String(name).toLowerCase());
+        if (!values || values.length === 0) {
+            return null;
+        }
+        let value = values.join(', ');
+        if (/^content-encoding$/i.test(name)) {
+            value = value.toLowerCase();
+        }
+        return value;
+    }
+    getAll(name) {
+        return this[_headers].get(String(name).toLowerCase()) ?? [];
+    }
+    getSetCookie() {
+        return this[_headers].get('set-cookie') ?? [];
+    }
+    forEach(callback, thisArg) {
+        for (const name of this.keys()) {
+            Reflect.apply(callback, thisArg, [this.get(name), name, this]);
+        }
+    }
+    *keys() {
+        const sorted = [...this[_headers].keys()].sort();
+        const seen = new Set();
+        for (const key of sorted) {
+            if (!seen.has(key)) {
+                seen.add(key);
+                yield key;
+            }
+        }
+    }
+    *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();
+    }
+    get [Symbol.toStringTag]() {
+        return 'Headers';
+    }
+    toString() {
+        return Object.prototype.toString.call(this);
+    }
+    /**
+     * Node-fetch non-spec method: return all headers and their values as arrays.
+     */
+    raw() {
+        const result = {};
+        for (const name of this.keys()) {
+            result[name] = this.getAll(name);
+        }
+        return result;
+    }
+    /**
+     * Append all headers to a Soup.Message for sending.
+     */
+    _appendToSoupMessage(message, type = Soup.MessageHeadersType.REQUEST) {
+        const soupHeaders = message ? message.get_request_headers() : new Soup.MessageHeaders(type);
+        for (const [name, value] of this.entries()) {
+            soupHeaders.append(name, value);
+        }
+        return soupHeaders;
+    }
+    /**
+     * Create a Headers instance from a Soup.Message's headers.
+     */
+    static _newFromSoupMessage(message, type = Soup.MessageHeadersType.RESPONSE) {
+        const headers = new Headers();
+        let soupHeaders;
+        if (type === Soup.MessageHeadersType.RESPONSE) {
+            soupHeaders = message.get_response_headers();
+        }
+        else {
+            soupHeaders = message.get_request_headers();
+        }
+        // Soup.MessageHeaders.foreach iterates all header name/value pairs
+        soupHeaders.foreach((name, value) => {
+            headers.append(name, value);
+        });
+        return headers;
+    }
+    /**
+     * For better console.log(headers)
+     */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        const result = {};
+        for (const key of this.keys()) {
+            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;
+}, {}));

package/lib/index.d.ts

@@ -0,0 +1,18 @@
+import Response from './response.js';
+import Headers from './headers.js';
+import Request 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 '@gjsify/formdata';
+import { Blob, File } from './utils/blob-from.js';
+import { URL } from '@gjsify/url';
+export { FormData, Headers, Request, Response, FetchError, AbortError, isRedirect };
+export { Blob, File };
+/**
+ * Fetch function
+ *
+ * @param url Absolute url or Request instance
+ * @param init Fetch options
+ */
+export default function fetch(url: RequestInfo | URL | Request, init?: RequestInit): Promise<Response>;