@gjsify/fetch 0.3.13 → 0.3.14

package/lib/esm/index.js

@@ -1,217 +1,232 @@
-import GLib from "@girs/glib-2.0";
-import Stream from "node:stream";
-import { parseDataUri } from "./utils/data-uri.js";
+import { Blob, File } from "./utils/blob-from.js";
+import { FetchError } from "./errors/fetch-error.js";
+import { isDomainOrSubdomain, isSameProtocol } from "./utils/is.js";
 import { clone } from "./body.js";
-import Response from "./response.js";
 import Headers from "./headers.js";
-import Request, { getSoupRequestOptions } from "./request.js";
-import { FetchError } from "./errors/fetch-error.js";
-import { AbortError } from "./errors/abort-error.js";
+import { parseDataUri } from "./utils/data-uri.js";
 import { isRedirect } from "./utils/is-redirect.js";
-import { FormData } from "@gjsify/formdata";
-import { isDomainOrSubdomain, isSameProtocol } from "./utils/is.js";
+import { Response } from "./response.js";
 import { parseReferrerPolicyFromHeader } from "./utils/referrer.js";
-import {
-  Blob,
-  File
-} from "./utils/blob-from.js";
-import { URL } from "@gjsify/url";
+import { Request, getSoupRequestOptions } from "./request.js";
+import { AbortError } from "./errors/abort-error.js";
 import { XMLHttpRequest, XMLHttpRequestUpload } from "./xhr.js";
-const supportedSchemas = /* @__PURE__ */ new Set(["data:", "http:", "https:", "file:"]);
+import { URL } from "@gjsify/url";
+import Stream from "node:stream";
+import { FormData } from "@gjsify/formdata";
+import GLib from "@girs/glib-2.0";
+
+//#region src/index.ts
+const supportedSchemas = new Set([
+	"data:",
+	"http:",
+	"https:",
+	"file:"
+]);
+/**
+* Rewrite root-relative URLs (e.g. `/res/images/foo.png`) to `file://` relative
+* to the program directory. In a browser these would resolve against the page
+* origin; in GJS there is no origin, so we map them to the running bundle's
+* directory. This lets apps use the same asset paths across browser and GJS.
+*/
+/**
+* Rewrite root-relative URLs (e.g. `/res/images/foo.png`) to `file://` relative
+* to the program directory. This lets GJS apps load bundled assets using the
+* same paths as in the browser. The security implications (arbitrary file
+* reads via fetch) are acceptable for the current use cases — revisit if
+* @gjsify/fetch is ever used to handle untrusted input.
+*/
 function rewriteRootRelativeUrl(input) {
-  if (typeof input !== "string") return input;
-  if (!input.startsWith("/") || input.startsWith("//")) return input;
-  const DEBUG = globalThis.__GJSIFY_DEBUG_FETCH === true;
-  try {
-    const imports = globalThis.imports;
-    const programPath = imports?.system?.programPath ?? imports?.system?.programInvocationName ?? "";
-    if (!programPath) return input;
-    const dir = GLib.path_get_dirname(programPath);
-    const rewritten = `file://${dir}${input}`;
-    if (DEBUG) console.log(`[fetch] rewrite ${input} \u2192 ${rewritten}`);
-    return rewritten;
-  } catch (err) {
-    if (DEBUG) console.warn(`[fetch] rewrite FAILED: ${err?.message ?? err}`);
-    return input;
-  }
+	if (typeof input !== "string") return input;
+	if (!input.startsWith("/") || input.startsWith("//")) return input;
+	const DEBUG = globalThis.__GJSIFY_DEBUG_FETCH === true;
+	try {
+		const imports = globalThis.imports;
+		const programPath = imports?.system?.programPath ?? imports?.system?.programInvocationName ?? "";
+		if (!programPath) return input;
+		const dir = GLib.path_get_dirname(programPath);
+		const rewritten = `file://${dir}${input}`;
+		if (DEBUG) console.log(`[fetch] rewrite ${input} → ${rewritten}`);
+		return rewritten;
+	} catch (err) {
+		if (DEBUG) console.warn(`[fetch] rewrite FAILED: ${err?.message ?? err}`);
+		return input;
+	}
 }
+/**
+* Fetch function
+*
+* @param url Absolute url or Request instance
+* @param init Fetch options
+*/
 async function fetch(url, init = {}) {
-  url = rewriteRootRelativeUrl(url);
-  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 { buffer, typeFull } = parseDataUri(request.url);
-    const response = new Response(Buffer.from(buffer), { headers: { "Content-Type": typeFull } });
-    return response;
-  }
-  if (parsedURL.protocol === "file:") {
-    const DEBUG = globalThis.__GJSIFY_DEBUG_FETCH === true;
-    if (DEBUG) console.log(`[fetch] file:// ${request.url}`);
-    try {
-      const path = GLib.filename_from_uri(request.url)[0];
-      if (DEBUG) console.log(`[fetch] file:// path=${path}`);
-      const [ok, contents] = GLib.file_get_contents(path);
-      if (DEBUG) console.log(`[fetch] file:// ok=${ok} bytes=${contents?.byteLength ?? "?"}`);
-      if (!ok) {
-        throw new FetchError(`Failed to read file: ${path}`, "system");
-      }
-      const bytes = contents;
-      const body = new Uint8Array(bytes.byteLength);
-      body.set(bytes);
-      const resp = new Response(body);
-      if (DEBUG) console.log(`[fetch] file:// response created`);
-      return resp;
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      if (DEBUG) console.warn(`[fetch] file:// FAIL: ${err.message}`);
-      throw new FetchError(`request to ${request.url} failed, reason: ${err.message}`, "system", err);
-    }
-  }
-  const { signal } = request;
-  if (signal && signal.aborted) {
-    throw new AbortError("The operation was aborted.");
-  }
-  let readable;
-  let cancellable;
-  try {
-    const sendRes = await request._send(options);
-    readable = sendRes.readable;
-    cancellable = sendRes.cancellable;
-  } catch (error) {
-    const err = error instanceof Error ? error : new Error(String(error));
-    throw new FetchError(`request to ${request.url} failed, reason: ${err.message}`, "system", err);
-  }
-  const abortHandler = () => {
-    cancellable.cancel();
-  };
-  if (signal) {
-    signal.addEventListener("abort", abortHandler, { once: true });
-  }
-  const finalize = () => {
-    if (signal) {
-      signal.removeEventListener("abort", abortHandler);
-    }
-  };
-  cancellable.connect(() => {
-    readable.destroy(new AbortError("The operation was aborted."));
-  });
-  readable.on("error", (error) => {
-    finalize();
-  });
-  const message = request._message;
-  const headers = Headers._newFromSoupMessage(message);
-  const statusCode = message.status_code;
-  const statusMessage = message.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") {
-        finalize();
-        throw new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, "invalid-redirect");
-      }
-    }
-    switch (request.redirect) {
-      case "error":
-        finalize();
-        throw new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, "no-redirect");
-      case "manual":
-        break;
-      case "follow": {
-        if (locationURL === null) {
-          break;
-        }
-        if (request.counter >= request.follow) {
-          finalize();
-          throw new FetchError(`maximum redirect reached at: ${request.url}`, "max-redirect");
-        }
-        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) {
-          finalize();
-          throw new FetchError("Cannot follow redirect with body being a readable stream", "unsupported-redirect");
-        }
-        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;
-        }
-        finalize();
-        return fetch(new Request(locationURL, requestOptions));
-      }
-      default:
-        throw new TypeError(`Redirect option '${request.redirect}' is not a valid value of RequestRedirect`);
-    }
-  }
-  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) {
-    finalize();
-    return new Response(readable, responseOptions);
-  }
-  if (typeof DecompressionStream !== "undefined") {
-    let format = null;
-    if (codings === "gzip" || codings === "x-gzip") {
-      format = "gzip";
-    } else if (codings === "deflate" || codings === "x-deflate") {
-      format = "deflate";
-    }
-    if (format) {
-      const webBody = new Response(readable, responseOptions).body;
-      if (webBody) {
-        const decompressed = webBody.pipeThrough(new DecompressionStream(format));
-        finalize();
-        return new Response(decompressed, responseOptions);
-      }
-    }
-  }
-  finalize();
-  return new Response(readable, responseOptions);
+	url = rewriteRootRelativeUrl(url);
+	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 { buffer, typeFull } = parseDataUri(request.url);
+		const response = new Response(Buffer.from(buffer), { headers: { "Content-Type": typeFull } });
+		return response;
+	}
+	if (parsedURL.protocol === "file:") {
+		const DEBUG = globalThis.__GJSIFY_DEBUG_FETCH === true;
+		if (DEBUG) console.log(`[fetch] file:// ${request.url}`);
+		try {
+			const path = GLib.filename_from_uri(request.url)[0];
+			if (DEBUG) console.log(`[fetch] file:// path=${path}`);
+			const [ok, contents] = GLib.file_get_contents(path);
+			if (DEBUG) console.log(`[fetch] file:// ok=${ok} bytes=${contents?.byteLength ?? "?"}`);
+			if (!ok) {
+				throw new FetchError(`Failed to read file: ${path}`, "system");
+			}
+			const bytes = contents;
+			const body = new Uint8Array(bytes.byteLength);
+			body.set(bytes);
+			const resp = new Response(body);
+			if (DEBUG) console.log(`[fetch] file:// response created`);
+			return resp;
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			if (DEBUG) console.warn(`[fetch] file:// FAIL: ${err.message}`);
+			throw new FetchError(`request to ${request.url} failed, reason: ${err.message}`, "system", err);
+		}
+	}
+	const { signal } = request;
+	if (signal && signal.aborted) {
+		throw new AbortError("The operation was aborted.");
+	}
+	let readable;
+	let cancellable;
+	try {
+		const sendRes = await request._send(options);
+		readable = sendRes.readable;
+		cancellable = sendRes.cancellable;
+	} catch (error) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		throw new FetchError(`request to ${request.url} failed, reason: ${err.message}`, "system", err);
+	}
+	const abortHandler = () => {
+		cancellable.cancel();
+	};
+	if (signal) {
+		signal.addEventListener("abort", abortHandler, { once: true });
+	}
+	const finalize = () => {
+		if (signal) {
+			signal.removeEventListener("abort", abortHandler);
+		}
+	};
+	cancellable.connect(() => {
+		readable.destroy(new AbortError("The operation was aborted."));
+	});
+	readable.on("error", (error) => {
+		finalize();
+	});
+	const message = request._message;
+	const headers = Headers._newFromSoupMessage(message);
+	const statusCode = message.status_code;
+	const statusMessage = message.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") {
+				finalize();
+				throw new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, "invalid-redirect");
+			}
+		}
+		switch (request.redirect) {
+			case "error":
+				finalize();
+				throw new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, "no-redirect");
+			case "manual": break;
+			case "follow": {
+				if (locationURL === null) {
+					break;
+				}
+				if (request.counter >= request.follow) {
+					finalize();
+					throw new FetchError(`maximum redirect reached at: ${request.url}`, "max-redirect");
+				}
+				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) {
+					finalize();
+					throw new FetchError("Cannot follow redirect with body being a readable stream", "unsupported-redirect");
+				}
+				if (statusCode === 303 || (statusCode === 301 || statusCode === 302) && request.method === "POST") {
+					requestOptions.method = "GET";
+					requestOptions.body = undefined;
+					requestOptions.headers.delete("content-length");
+				}
+				const responseReferrerPolicy = parseReferrerPolicyFromHeader(headers);
+				if (responseReferrerPolicy) {
+					requestOptions.referrerPolicy = responseReferrerPolicy;
+				}
+				finalize();
+				return fetch(new Request(locationURL, requestOptions));
+			}
+			default: throw new TypeError(`Redirect option '${request.redirect}' is not a valid value of RequestRedirect`);
+		}
+	}
+	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) {
+		finalize();
+		return new Response(readable, responseOptions);
+	}
+	if (typeof DecompressionStream !== "undefined") {
+		let format = null;
+		if (codings === "gzip" || codings === "x-gzip") {
+			format = "gzip";
+		} else if (codings === "deflate" || codings === "x-deflate") {
+			format = "deflate";
+		}
+		if (format) {
+			const webBody = new Response(readable, responseOptions).body;
+			if (webBody) {
+				const decompressed = webBody.pipeThrough(new DecompressionStream(format));
+				finalize();
+				return new Response(decompressed, responseOptions);
+			}
+		}
+	}
+	finalize();
+	return new Response(readable, responseOptions);
 }
-export {
-  AbortError,
-  Blob,
-  FetchError,
-  File,
-  FormData,
-  Headers,
-  Request,
-  Response,
-  XMLHttpRequest,
-  XMLHttpRequestUpload,
-  fetch as default,
-  isRedirect
-};
+
+//#endregion
+export { AbortError, Blob, FetchError, File, FormData, Headers, Request, Response, XMLHttpRequest, XMLHttpRequestUpload, fetch as default, isRedirect };

package/lib/esm/register/fetch.js

@@ -1,13 +1,20 @@
-import fetch, { Headers, Request, Response } from "../index.js";
+import Headers from "../headers.js";
+import { Response } from "../response.js";
+import { Request } from "../request.js";
+import fetch from "../index.js";
+
+//#region src/register/fetch.ts
 if (typeof globalThis.fetch === "undefined") {
-  globalThis.fetch = fetch;
+	globalThis.fetch = fetch;
 }
 if (typeof globalThis.Headers === "undefined") {
-  globalThis.Headers = Headers;
+	globalThis.Headers = Headers;
 }
 if (typeof globalThis.Request === "undefined") {
-  globalThis.Request = Request;
+	globalThis.Request = Request;
 }
 if (typeof globalThis.Response === "undefined") {
-  globalThis.Response = Response;
+	globalThis.Response = Response;
 }
+
+//#endregion

package/lib/esm/register/xhr.js

@@ -1,7 +1,11 @@
 import { XMLHttpRequest, XMLHttpRequestUpload } from "../xhr.js";
+
+//#region src/register/xhr.ts
 if (typeof globalThis.XMLHttpRequest === "undefined") {
-  globalThis.XMLHttpRequest = XMLHttpRequest;
+	globalThis.XMLHttpRequest = XMLHttpRequest;
 }
 if (typeof globalThis.XMLHttpRequestUpload === "undefined") {
-  globalThis.XMLHttpRequestUpload = XMLHttpRequestUpload;
+	globalThis.XMLHttpRequestUpload = XMLHttpRequestUpload;
 }
+
+//#endregion