@gjsify/fetch 0.0.3 → 0.1.0

package/lib/response.js

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: MIT
+// Adapted from node-fetch (https://github.com/node-fetch/node-fetch/blob/main/src/response.js)
+// Copyright (c) node-fetch contributors. MIT license.
+// Modifications: Rewritten for GJS using Gio streams and GLib
+import GLib from '@girs/glib-2.0';
+import Gio from '@girs/gio-2.0';
+import Headers from './headers.js';
+import Body, { clone, extractContentType } from './body.js';
+import { isRedirect } from './utils/is-redirect.js';
+import { URL } from '@gjsify/url';
+const INTERNALS = Symbol('Response internals');
+/**
+ * Response class
+ *
+ * Ref: https://fetch.spec.whatwg.org/#response-class
+ *
+ * @param body Readable stream
+ * @param opts Response options
+ */
+export class Response extends Body {
+    [INTERNALS];
+    _inputStream = null;
+    constructor(body = null, options = {}) {
+        super(body, options);
+        // eslint-disable-next-line no-eq-null, eqeqeq, no-negated-condition
+        const status = options.status != null ? options.status : 200;
+        const headers = new Headers(options.headers);
+        if (body !== null && !headers.has('Content-Type')) {
+            const contentType = 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
+     */
+    clone() {
+        return new Response(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 (!isRedirect(status)) {
+            throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
+        }
+        return new Response(null, {
+            headers: {
+                location: new URL(url).toString()
+            },
+            status
+        });
+    }
+    static error() {
+        const response = new Response(null, { status: 0, statusText: '' });
+        response[INTERNALS].type = 'error';
+        return response;
+    }
+    /**
+     * Create a Response with a JSON body.
+     * @param data The data to serialize as JSON.
+     * @param init Optional response init options.
+     * @returns A Response with the JSON body and appropriate content-type header.
+     */
+    static json(data, init) {
+        const body = JSON.stringify(data);
+        const options = { ...init };
+        const headers = new Headers(options.headers);
+        if (!headers.has('content-type')) {
+            headers.set('content-type', 'application/json');
+        }
+        options.headers = headers;
+        return new Response(body, options);
+    }
+    get [Symbol.toStringTag]() {
+        return 'Response';
+    }
+    async text() {
+        if (!this._inputStream) {
+            return super.text();
+        }
+        const outputStream = Gio.MemoryOutputStream.new_resizable();
+        await new Promise((resolve, reject) => {
+            outputStream.splice_async(this._inputStream, Gio.OutputStreamSpliceFlags.CLOSE_TARGET | Gio.OutputStreamSpliceFlags.CLOSE_SOURCE, GLib.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 }
+});
+export default Response;

package/lib/types/index.d.ts

@@ -0,0 +1 @@
+export * from './system-error.js';

package/lib/types/index.js

@@ -0,0 +1 @@
+export * from './system-error.js';

package/lib/types/system-error.d.ts

@@ -0,0 +1,11 @@
+export interface SystemError {
+    address?: string;
+    code: string;
+    dest?: string;
+    errno: number;
+    info?: object;
+    message: string;
+    path?: string;
+    port?: number;
+    syscall: string;
+}

package/lib/types/system-error.js

@@ -0,0 +1,2 @@
+;
+export {};

package/lib/utils/blob-from.d.ts

@@ -0,0 +1,2 @@
+import { Blob, File } from 'node:buffer';
+export { Blob, File, };

package/lib/utils/blob-from.js

@@ -0,0 +1,4 @@
+// Re-export Blob/File from buffer (which provides the polyfill on GJS)
+// Reference: Node.js buffer.Blob (available since v18)
+import { Blob, File } from 'node:buffer';
+export { Blob, File, };

package/lib/utils/data-uri.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parse a data: URI into its components.
+ * Replaces the `data-uri-to-buffer` npm package.
+ *
+ * Format: data:[<mediatype>][;base64],<data>
+ */
+export declare function parseDataUri(uri: string): {
+    buffer: Uint8Array;
+    typeFull: string;
+};

package/lib/utils/data-uri.js

@@ -0,0 +1,27 @@
+/**
+ * Parse a data: URI into its components.
+ * Replaces the `data-uri-to-buffer` npm package.
+ *
+ * Format: data:[<mediatype>][;base64],<data>
+ */
+export 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 };
+}

package/lib/utils/get-search.d.ts

@@ -0,0 +1 @@
+export declare const getSearch: (parsedURL: URL) => string;

package/lib/utils/get-search.js

@@ -0,0 +1,8 @@
+export 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/utils/is-redirect.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Redirect code matching
+ *
+ * @param {number} code - Status code
+ * @return {boolean}
+ */
+export declare const isRedirect: (code: any) => boolean;

package/lib/utils/is-redirect.js

@@ -0,0 +1,10 @@
+const redirectStatus = new Set([301, 302, 303, 307, 308]);
+/**
+ * Redirect code matching
+ *
+ * @param {number} code - Status code
+ * @return {boolean}
+ */
+export const isRedirect = code => {
+    return redirectStatus.has(code);
+};

package/lib/utils/is.d.ts

@@ -0,0 +1,35 @@
+import { Blob } from './blob-from.js';
+/**
+ * Check if `obj` is a URLSearchParams object
+ * ref: https://github.com/node-fetch/node-fetch/issues/296#issuecomment-307598143
+ * @param {*} object - Object to check for
+ * @return {boolean}
+ */
+export declare const isURLSearchParameters: (object: any) => boolean;
+/**
+ * Check if `object` is a W3C `Blob` object (which `File` inherits from)
+ * @param object Object to check for
+ */
+export declare const isBlob: (value: unknown) => value is Blob;
+/**
+ * Check if `obj` is an instance of AbortSignal.
+ * @param object - Object to check for
+ */
+export declare const isAbortSignal: (object: unknown) => object is AbortSignal;
+/**
+ * isDomainOrSubdomain reports whether sub is a subdomain (or exact match) of
+ * the parent domain.
+ *
+ * Both domains must already be in canonical form.
+ * @param {string|URL} original
+ * @param {string|URL} destination
+ */
+export declare const isDomainOrSubdomain: (destination: any, original: any) => boolean;
+/**
+ * isSameProtocol reports whether the two provided URLs use the same protocol.
+ *
+ * Both domains must already be in canonical form.
+ * @param {string|URL} original
+ * @param {string|URL} destination
+ */
+export declare const isSameProtocol: (destination: any, original: any) => boolean;

package/lib/utils/is.js

@@ -0,0 +1,74 @@
+import { URL } from '@gjsify/url';
+/**
+ * Is.js
+ *
+ * Object type checks.
+ */
+const NAME = Symbol.toStringTag;
+/**
+ * Check if `obj` is a URLSearchParams object
+ * ref: https://github.com/node-fetch/node-fetch/issues/296#issuecomment-307598143
+ * @param {*} object - Object to check for
+ * @return {boolean}
+ */
+export 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');
+};
+/**
+ * Check if `object` is a W3C `Blob` object (which `File` inherits from)
+ * @param object Object to check for
+ */
+export const isBlob = (value) => {
+    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]));
+};
+/**
+ * Check if `obj` is an instance of AbortSignal.
+ * @param object - Object to check for
+ */
+export const isAbortSignal = (object) => {
+    if (typeof object !== 'object' || object === null)
+        return false;
+    const obj = object;
+    return (obj[NAME] === 'AbortSignal' ||
+        obj[NAME] === 'EventTarget');
+};
+/**
+ * isDomainOrSubdomain reports whether sub is a subdomain (or exact match) of
+ * the parent domain.
+ *
+ * Both domains must already be in canonical form.
+ * @param {string|URL} original
+ * @param {string|URL} destination
+ */
+export const isDomainOrSubdomain = (destination, original) => {
+    const orig = new URL(original).hostname;
+    const dest = new URL(destination).hostname;
+    return orig === dest || orig.endsWith(`.${dest}`);
+};
+/**
+ * isSameProtocol reports whether the two provided URLs use the same protocol.
+ *
+ * Both domains must already be in canonical form.
+ * @param {string|URL} original
+ * @param {string|URL} destination
+ */
+export const isSameProtocol = (destination, original) => {
+    const orig = new URL(original).protocol;
+    const dest = new URL(destination).protocol;
+    return orig === dest;
+};

package/lib/utils/multipart-parser.d.ts

@@ -0,0 +1,2 @@
+import { FormData } from '@gjsify/formdata';
+export declare function toFormData(Body: any, ct: any): Promise<FormData>;