@gjsify/fetch 0.1.13 → 0.2.0

package/lib/body.d.ts

@@ -29,6 +29,8 @@ export default class Body {
     });
     get body(): ReadableStream<Uint8Array> | null;
     get _stream(): Readable;
+    /** Return the raw body buffer without consuming the stream (used by Request._send). */
+    get _rawBodyBuffer(): Buffer | null;
     get bodyUsed(): boolean;
     /**
      * Decode response as ArrayBuffer

package/lib/body.js

@@ -124,19 +124,41 @@ export default class Body {
             return null;
         // If ReadableStream is available, wrap the Readable into one
         if (typeof ReadableStream !== 'undefined') {
+            let closed = false;
             return new ReadableStream({
                 start(controller) {
                     stream.on('data', (chunk) => {
-                        controller.enqueue(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
+                        if (closed)
+                            return;
+                        try {
+                            controller.enqueue(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
+                        }
+                        catch { /* consumer cancelled — drop */ }
                     });
                     stream.on('end', () => {
-                        controller.close();
+                        if (closed)
+                            return;
+                        closed = true;
+                        // Defensive: consumer may have cancelled the stream already,
+                        // in which case .close() throws TypeError. Don't surface that
+                        // as an unhandled error in the nextTick queue.
+                        try {
+                            controller.close();
+                        }
+                        catch { /* already closed/cancelled */ }
                     });
                     stream.on('error', (err) => {
-                        controller.error(err);
+                        if (closed)
+                            return;
+                        closed = true;
+                        try {
+                            controller.error(err);
+                        }
+                        catch { /* already closed/cancelled */ }
                     });
                 },
                 cancel() {
+                    closed = true;
                     stream.destroy();
                 }
             });
@@ -146,6 +168,17 @@ export default class Body {
     get _stream() {
         return this[INTERNALS].stream;
     }
+    /** Return the raw body buffer without consuming the stream (used by Request._send). */
+    get _rawBodyBuffer() {
+        const b = this[INTERNALS].body;
+        if (b === null)
+            return null;
+        if (Buffer.isBuffer(b))
+            return b;
+        if (b instanceof Uint8Array)
+            return Buffer.from(b.buffer, b.byteOffset, b.byteLength);
+        return null;
+    }
     get bodyUsed() {
         return this[INTERNALS].disturbed;
     }

package/lib/esm/body.js

@@ -77,19 +77,35 @@ class Body {
     const stream = this[INTERNALS].stream;
     if (!stream) return null;
     if (typeof ReadableStream !== "undefined") {
+      let closed = false;
       return new ReadableStream({
         start(controller) {
           stream.on("data", (chunk) => {
-            controller.enqueue(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
+            if (closed) return;
+            try {
+              controller.enqueue(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
+            } catch {
+            }
           });
           stream.on("end", () => {
-            controller.close();
+            if (closed) return;
+            closed = true;
+            try {
+              controller.close();
+            } catch {
+            }
           });
           stream.on("error", (err) => {
-            controller.error(err);
+            if (closed) return;
+            closed = true;
+            try {
+              controller.error(err);
+            } catch {
+            }
           });
         },
         cancel() {
+          closed = true;
           stream.destroy();
         }
       });
@@ -99,6 +115,14 @@ class Body {
   get _stream() {
     return this[INTERNALS].stream;
   }
+  /** Return the raw body buffer without consuming the stream (used by Request._send). */
+  get _rawBodyBuffer() {
+    const b = this[INTERNALS].body;
+    if (b === null) return null;
+    if (Buffer.isBuffer(b)) return b;
+    if (b instanceof Uint8Array) return Buffer.from(b.buffer, b.byteOffset, b.byteLength);
+    return null;
+  }
   get bodyUsed() {
     return this[INTERNALS].disturbed;
   }

package/lib/esm/index.js

@@ -16,6 +16,7 @@ import {
   File
 } from "./utils/blob-from.js";
 import { URL } from "@gjsify/url";
+import { XMLHttpRequest, XMLHttpRequestUpload } from "./xhr.js";
 const supportedSchemas = /* @__PURE__ */ new Set(["data:", "http:", "https:", "file:"]);
 function rewriteRootRelativeUrl(input) {
   if (typeof input !== "string") return input;
@@ -94,7 +95,7 @@ async function fetch(url, init = {}) {
       signal.removeEventListener("abort", abortHandler);
     }
   };
-  cancellable.connect("cancelled", () => {
+  cancellable.connect(() => {
     readable.destroy(new AbortError("The operation was aborted."));
   });
   readable.on("error", (error) => {
@@ -209,6 +210,8 @@ export {
   Headers,
   Request,
   Response,
+  XMLHttpRequest,
+  XMLHttpRequestUpload,
   fetch as default,
   isRedirect
 };

package/lib/esm/register/xhr.js

@@ -0,0 +1,7 @@
+import { XMLHttpRequest, XMLHttpRequestUpload } from "../xhr.js";
+if (typeof globalThis.XMLHttpRequest === "undefined") {
+  globalThis.XMLHttpRequest = XMLHttpRequest;
+}
+if (typeof globalThis.XMLHttpRequestUpload === "undefined") {
+  globalThis.XMLHttpRequestUpload = XMLHttpRequestUpload;
+}

package/lib/esm/register.js

@@ -1 +1,2 @@
 import "./register/fetch.js";
+import "./register/xhr.js";

package/lib/esm/request.js

@@ -181,7 +181,16 @@ class Request extends Body {
     if (!session || !message) {
       throw new Error("Cannot send request: no Soup session (non-HTTP URL?)");
     }
+    try {
+      session.remove_feature_by_type(Soup.ContentDecoder.$gtype);
+    } catch {
+    }
     options.headers._appendToSoupMessage(message);
+    const rawBuf = this._rawBodyBuffer;
+    if (rawBuf !== null && rawBuf.byteLength > 0) {
+      const contentType = options.headers.get("content-type") || null;
+      message.set_request_body_from_bytes(contentType, new GLib.Bytes(rawBuf));
+    }
     const cancellable = new Gio.Cancellable();
     this[INTERNALS].inputStream = await soupSendAsync(session, message, GLib.PRIORITY_DEFAULT, cancellable);
     this[INTERNALS].readable = inputStreamToReadable(this[INTERNALS].inputStream);
@@ -258,7 +267,7 @@ const getSoupRequestOptions = (request) => {
     headers.set("User-Agent", "gjsify-fetch");
   }
   if (request.compress && !headers.has("Accept-Encoding")) {
-    headers.set("Accept-Encoding", "gzip, deflate, br");
+    headers.set("Accept-Encoding", "gzip, deflate");
   }
   let { agent } = request;
   if (typeof agent === "function") {

package/lib/esm/xhr.js

@@ -0,0 +1,258 @@
+import GLib from "gi://GLib?version=2.0";
+import fetch from "./index.js";
+let _blobCounter = 0;
+function guessBlobExt(url) {
+  const lower = url.toLowerCase().split("?")[0];
+  const dot = lower.lastIndexOf(".");
+  const ext = dot > -1 ? lower.slice(dot) : "";
+  switch (ext) {
+    case ".png":
+    case ".jpg":
+    case ".jpeg":
+    case ".gif":
+    case ".webp":
+    case ".svg":
+    case ".bmp":
+    case ".ttf":
+    case ".otf":
+    case ".woff":
+    case ".woff2":
+    case ".mp3":
+    case ".wav":
+    case ".ogg":
+    case ".flac":
+    case ".m4a":
+    case ".mp4":
+    case ".webm":
+    case ".mkv":
+    case ".xml":
+    case ".tmx":
+    case ".json":
+      return ext;
+    default:
+      return ".bin";
+  }
+}
+function writeBlobToTempFile(bytes, url) {
+  const tmpPath = GLib.build_filenamev([
+    GLib.get_tmp_dir(),
+    `gjsify-blob-${_blobCounter++}${guessBlobExt(url)}`
+  ]);
+  GLib.file_set_contents(tmpPath, bytes);
+  return tmpPath;
+}
+const UNSENT = 0;
+const OPENED = 1;
+const HEADERS_RECEIVED = 2;
+const LOADING = 3;
+const DONE = 4;
+class XMLHttpRequest extends EventTarget {
+  static UNSENT = UNSENT;
+  static OPENED = OPENED;
+  static HEADERS_RECEIVED = HEADERS_RECEIVED;
+  static LOADING = LOADING;
+  static DONE = DONE;
+  UNSENT = UNSENT;
+  OPENED = OPENED;
+  HEADERS_RECEIVED = HEADERS_RECEIVED;
+  LOADING = LOADING;
+  DONE = DONE;
+  readyState = UNSENT;
+  status = 0;
+  statusText = "";
+  responseType = "";
+  responseText = "";
+  response = null;
+  responseURL = "";
+  withCredentials = false;
+  timeout = 0;
+  upload = new XMLHttpRequestUpload();
+  onreadystatechange = null;
+  onload = null;
+  onerror = null;
+  onabort = null;
+  ontimeout = null;
+  onloadstart = null;
+  onloadend = null;
+  onprogress = null;
+  _method = "GET";
+  _url = "";
+  _headers = /* @__PURE__ */ new Map();
+  _responseHeaders = /* @__PURE__ */ new Map();
+  _controller = new AbortController();
+  _aborted = false;
+  _timeoutId = null;
+  open(method, url, _async = true, _user, _password) {
+    this._method = method.toUpperCase();
+    this._url = url;
+    this._headers.clear();
+    this._responseHeaders.clear();
+    this._aborted = false;
+    this._controller = new AbortController();
+    this._setReadyState(OPENED);
+  }
+  setRequestHeader(header, value) {
+    if (this.readyState < OPENED) throw new DOMException("Must open first", "InvalidStateError");
+    this._headers.set(header.toLowerCase(), value);
+  }
+  getResponseHeader(header) {
+    return this._responseHeaders.get(header.toLowerCase()) ?? null;
+  }
+  getAllResponseHeaders() {
+    const lines = [];
+    this._responseHeaders.forEach((v, k) => lines.push(`${k}: ${v}`));
+    return lines.join("\r\n");
+  }
+  send(body) {
+    if (this.readyState !== OPENED) throw new DOMException("Must open first", "InvalidStateError");
+    if (this._aborted) return;
+    const headersInit = {};
+    this._headers.forEach((v, k) => {
+      headersInit[k] = v;
+    });
+    const fetchOptions = {
+      method: this._method,
+      headers: headersInit,
+      credentials: this.withCredentials ? "include" : "omit",
+      signal: this._controller.signal
+    };
+    if (body != null && this._method !== "GET" && this._method !== "HEAD") {
+      fetchOptions.body = body;
+    }
+    if (this.timeout > 0) {
+      this._timeoutId = setTimeout(() => {
+        this._controller.abort();
+        this._onTimeout();
+      }, this.timeout);
+    }
+    this.dispatchEvent(new Event("loadstart"));
+    if (this.onloadstart) this.onloadstart(new ProgressEvent("loadstart"));
+    fetch(this._url, fetchOptions).then(async (res) => {
+      if (this._aborted) return;
+      if (this._timeoutId) {
+        clearTimeout(this._timeoutId);
+        this._timeoutId = null;
+      }
+      this.status = res.status;
+      this.statusText = res.statusText;
+      this.responseURL = res.url;
+      res.headers.forEach((v, k) => {
+        this._responseHeaders.set(k.toLowerCase(), v);
+      });
+      this._setReadyState(HEADERS_RECEIVED);
+      this._setReadyState(LOADING);
+      switch (this.responseType) {
+        case "arraybuffer": {
+          const ab = await res.arrayBuffer();
+          this.response = ab;
+          this.responseText = "";
+          break;
+        }
+        case "blob": {
+          const ab = await res.arrayBuffer();
+          const bytes = new Uint8Array(ab);
+          const tmpPath = writeBlobToTempFile(bytes, this._url);
+          const blob = new Blob([ab], {
+            type: this._responseHeaders.get("content-type") ?? ""
+          });
+          blob._tmpPath = tmpPath;
+          this.response = blob;
+          this.responseText = "";
+          break;
+        }
+        case "json": {
+          const text = await res.text();
+          this.responseText = "";
+          try {
+            this.response = text.length > 0 ? JSON.parse(text) : null;
+          } catch {
+            this.response = null;
+          }
+          break;
+        }
+        case "document": {
+          const text = await res.text();
+          this.responseText = text;
+          this.response = text;
+          break;
+        }
+        case "":
+        case "text":
+        default: {
+          const text = await res.text();
+          const stripped = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+          this.responseText = stripped;
+          this.response = stripped;
+          break;
+        }
+      }
+      this._setReadyState(DONE);
+      this.dispatchEvent(new ProgressEvent("load"));
+      this.dispatchEvent(new ProgressEvent("loadend"));
+      if (this.onload) this.onload(new ProgressEvent("load"));
+      if (this.onloadend) this.onloadend(new ProgressEvent("loadend"));
+    }).catch((_err) => {
+      if (this._timeoutId) {
+        clearTimeout(this._timeoutId);
+        this._timeoutId = null;
+      }
+      if (this._aborted) return;
+      this._setReadyState(DONE);
+      const ev = new ProgressEvent("error");
+      this.dispatchEvent(ev);
+      if (this.onerror) this.onerror(ev);
+      if (this.onloadend) this.onloadend(new ProgressEvent("loadend"));
+    });
+  }
+  abort() {
+    if (this._aborted) return;
+    this._aborted = true;
+    if (this._timeoutId) {
+      clearTimeout(this._timeoutId);
+      this._timeoutId = null;
+    }
+    this._controller.abort();
+    if (this.readyState !== UNSENT && this.readyState !== DONE) {
+      this._setReadyState(DONE);
+      this.status = 0;
+    }
+    const ev = new ProgressEvent("abort");
+    this.dispatchEvent(ev);
+    if (this.onabort) this.onabort(ev);
+    if (this.onloadend) this.onloadend(new ProgressEvent("loadend"));
+  }
+  overrideMimeType(_mime) {
+  }
+  _onTimeout() {
+    if (this._aborted) return;
+    this._aborted = true;
+    this._setReadyState(DONE);
+    const ev = new ProgressEvent("timeout");
+    this.dispatchEvent(ev);
+    if (this.ontimeout) this.ontimeout(ev);
+  }
+  _setReadyState(state) {
+    this.readyState = state;
+    const ev = new Event("readystatechange");
+    this.dispatchEvent(ev);
+    if (this.onreadystatechange) this.onreadystatechange(ev);
+  }
+}
+class XMLHttpRequestUpload extends EventTarget {
+  onprogress = null;
+  onloadstart = null;
+  onloadend = null;
+  onload = null;
+  onerror = null;
+  onabort = null;
+  ontimeout = null;
+}
+export {
+  DONE,
+  HEADERS_RECEIVED,
+  LOADING,
+  OPENED,
+  UNSENT,
+  XMLHttpRequest,
+  XMLHttpRequestUpload
+};

package/lib/index.d.ts

@@ -9,6 +9,7 @@ import { Blob, File } from './utils/blob-from.js';
 import { URL } from '@gjsify/url';
 export { FormData, Headers, Request, Response, FetchError, AbortError, isRedirect };
 export { Blob, File };
+export { XMLHttpRequest, XMLHttpRequestUpload } from './xhr.js';
 /**
  * Fetch function
  *

package/lib/index.js

@@ -19,6 +19,7 @@ import { Blob, File, } from './utils/blob-from.js';
 import { URL } from '@gjsify/url';
 export { FormData, Headers, Request, Response, FetchError, AbortError, isRedirect };
 export { Blob, File };
+export { XMLHttpRequest, XMLHttpRequestUpload } from './xhr.js';
 const supportedSchemas = new Set(['data:', 'http:', 'https:', 'file:']);
 /**
  * Rewrite root-relative URLs (e.g. `/res/images/foo.png`) to `file://` relative
@@ -141,8 +142,10 @@ export default async function fetch(url, init = {}) {
             signal.removeEventListener('abort', abortHandler);
         }
     };
-    // Listen for cancellation
-    cancellable.connect('cancelled', () => {
+    // Listen for cancellation.
+    // Gio.Cancellable.connect() is g_cancellable_connect() — pass callback + DestroyNotify (or null).
+    // NOT a GObject signal: do NOT pass a signal name as the first argument.
+    cancellable.connect(() => {
         readable.destroy(new AbortError('The operation was aborted.'));
     });
     // Handle stream errors

package/lib/index.spec.js

@@ -1,5 +1,9 @@
 import { describe, it, expect, on } from '@gjsify/unit';
-import fetch, { Headers, Request, Response } from 'fetch';
+// fetch / Headers / Request / Response / FormData are accessed off globalThis:
+// on Node they are native, on GJS they are installed by
+// `@gjsify/fetch/register` (pulled in automatically by `--globals auto`).
+// XMLHttpRequest is GJS-only and is likewise read from globalThis inside an
+// on('Gjs', …) gate further below.
 export default async () => {
     await describe('fetch', async () => {
         await it('fetch should be a function', async () => {
@@ -146,9 +150,14 @@ export default async () => {
             expect(clone.method).toBe('POST');
             expect(clone.headers.get('x-test')).toBe('value');
         });
-        await it('should create request with null body', async () => {
-            const r = new Request('https://example.com', { body: null });
-            expect(r.body).toBeNull();
+        // Firefox returns a non-null body for new Request(url, { body: null }) — likely
+        // an empty ReadableStream — contrary to the spec (body: null → r.body === null).
+        // Guard to Node.js + GJS where spec-correct behavior is verified.
+        await on(['Node.js', 'Gjs'], async () => {
+            await it('should create request with null body', async () => {
+                const r = new Request('https://example.com', { body: null });
+                expect(r.body).toBeNull();
+            });
         });
     });
     await describe('Response', async () => {
@@ -235,4 +244,50 @@ export default async () => {
             expect(text).toBe('hello');
         });
     });
+    await on('Gjs', async () => {
+        await describe('XMLHttpRequest responseType', async () => {
+            // Regression: Excalibur.js sets responseType='arraybuffer' for audio and
+            // 'blob' for images. Before this fix XHR ignored responseType and always
+            // returned text, which crashed gst_memory_new_wrapped on audio decode and
+            // broke URL.createObjectURL on image load.
+            //
+            // XMLHttpRequest is accessed off globalThis (not imported). On GJS it's
+            // registered by `@gjsify/fetch/register/xhr` (pulled in by --globals
+            // auto when the detector sees `new XMLHttpRequest()`); on Node there
+            // is no native XMLHttpRequest, so the suite is gated with on('Gjs', …).
+            const XHR = globalThis.XMLHttpRequest;
+            const runXhr = (init) => new Promise((resolve, reject) => {
+                const xhr = new XHR();
+                xhr.open('GET', 'data:text/plain;base64,aGVsbG8=');
+                init(xhr);
+                xhr.onload = () => resolve(xhr);
+                xhr.onerror = () => reject(new Error('xhr error'));
+                xhr.send();
+            });
+            await it('responseType="arraybuffer" yields ArrayBuffer', async () => {
+                const xhr = await runXhr((x) => { x.responseType = 'arraybuffer'; });
+                expect(xhr.response instanceof ArrayBuffer).toBe(true);
+                expect(xhr.response.byteLength).toBe(5);
+            });
+            await it('responseType="text" yields decoded string', async () => {
+                const xhr = await runXhr((x) => { x.responseType = 'text'; });
+                expect(xhr.response).toBe('hello');
+                expect(xhr.responseText).toBe('hello');
+            });
+            await it('default responseType "" yields text', async () => {
+                const xhr = await runXhr(() => { });
+                expect(xhr.response).toBe('hello');
+                expect(xhr.responseText).toBe('hello');
+            });
+            await it('responseType="blob" attaches _tmpPath for URL.createObjectURL', async () => {
+                const xhr = await runXhr((x) => { x.responseType = 'blob'; });
+                const blob = xhr.response;
+                expect(blob instanceof Blob).toBe(true);
+                expect(typeof blob._tmpPath).toBe('string');
+                const url = URL.createObjectURL(blob);
+                expect(url.startsWith('file://')).toBe(true);
+                URL.revokeObjectURL(url);
+            });
+        });
+    });
 };

package/lib/register/xhr.d.ts

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

package/lib/register/xhr.js

@@ -0,0 +1,18 @@
+// Registers XMLHttpRequest / XMLHttpRequestUpload on globalThis.
+//
+// The Blob → file:// URL chain required by Excalibur's ImageSource / FontFace
+// is split across two packages:
+//   - `@gjsify/fetch` XHR (this package): when responseType='blob', materialise
+//     the response to a GLib temp file and attach `_tmpPath` to the returned
+//     Blob.
+//   - `@gjsify/url` URL class: `URL.createObjectURL(blob)` reads `_tmpPath`
+//     and returns a `file://` URL that HTMLImageElement etc. can load.
+//
+// There is no URL monkey-patching here — URL owns createObjectURL natively.
+import { XMLHttpRequest, XMLHttpRequestUpload } from '../xhr.js';
+if (typeof globalThis.XMLHttpRequest === 'undefined') {
+    globalThis.XMLHttpRequest = XMLHttpRequest;
+}
+if (typeof globalThis.XMLHttpRequestUpload === 'undefined') {
+    globalThis.XMLHttpRequestUpload = XMLHttpRequestUpload;
+}

package/lib/register.d.ts

@@ -1 +1,2 @@
 import './register/fetch.js';
+import './register/xhr.js';

package/lib/register.js

@@ -1,3 +1,4 @@
-// Catch-all side-effect module: registers fetch/Headers/Request/Response.
-// For granular imports use '@gjsify/fetch/register/fetch'.
+// Catch-all side-effect module: registers fetch/Headers/Request/Response + XMLHttpRequest.
+// For granular imports use '@gjsify/fetch/register/fetch' or '@gjsify/fetch/register/xhr'.
 import './register/fetch.js';
+import './register/xhr.js';

package/lib/request.js

@@ -200,7 +200,24 @@ export class Request extends Body {
         if (!session || !message) {
             throw new Error('Cannot send request: no Soup session (non-HTTP URL?)');
         }
+        // Soup auto-adds ContentDecoder to new sessions, but it decodes the body
+        // without removing the Content-Encoding header, causing double-decompression
+        // if we also run DecompressionStream below. Remove it so our JS-level
+        // decompression in index.ts handles everything correctly.
+        try {
+            session.remove_feature_by_type(Soup.ContentDecoder.$gtype);
+        }
+        catch { /* not present */ }
         options.headers._appendToSoupMessage(message);
+        // Attach the request body to the Soup message (needed for POST/PUT/PATCH).
+        // Use _rawBodyBuffer to read the body without consuming the stream (the
+        // `body` getter may have already put the internal Readable into flowing mode,
+        // draining its buffer before we get here).
+        const rawBuf = this._rawBodyBuffer;
+        if (rawBuf !== null && rawBuf.byteLength > 0) {
+            const contentType = options.headers.get('content-type') || null;
+            message.set_request_body_from_bytes(contentType, new GLib.Bytes(rawBuf));
+        }
         const cancellable = new Gio.Cancellable();
         this[INTERNALS].inputStream = await soupSendAsync(session, message, GLib.PRIORITY_DEFAULT, cancellable);
         this[INTERNALS].readable = inputStreamToReadable(this[INTERNALS].inputStream);
@@ -287,9 +304,11 @@ export const getSoupRequestOptions = (request) => {
     if (!headers.has('User-Agent')) {
         headers.set('User-Agent', 'gjsify-fetch');
     }
-    // HTTP-network-or-cache fetch step 2.15
+    // HTTP-network-or-cache fetch step 2.15. Brotli ('br') is omitted: SpiderMonkey
+    // 128's DecompressionStream supports only 'gzip' and 'deflate', so advertising
+    // 'br' would let servers respond with bodies we cannot decode.
     if (request.compress && !headers.has('Accept-Encoding')) {
-        headers.set('Accept-Encoding', 'gzip, deflate, br');
+        headers.set('Accept-Encoding', 'gzip, deflate');
     }
     let { agent } = request;
     if (typeof agent === 'function') {