@qelos/aidev 0.11.0 → 1.0.1

package/ui/.output/server/node_modules/jsdom/lib/jsdom/browser/resources/per-document-resource-loader.js

@@ -0,0 +1,116 @@
+"use strict";
+const idlUtils = require("../../../generated/idl/utils");
+const { fireAnEvent } = require("../../living/helpers/events");
+const { fetchCollected } = require("./jsdom-dispatcher");
+
+module.exports = class PerDocumentResourceLoader {
+  constructor(document) {
+    this._document = document;
+    this._defaultEncoding = document._encoding;
+    const defaultView = document._defaultView;
+    this._dispatcher = defaultView ? defaultView._dispatcher : null;
+    this._loadSubresources = defaultView ? defaultView._loadSubresources : false;
+    this._requestManager = document._requestManager;
+    this._queue = document._queue;
+    this._deferQueue = document._deferQueue;
+    this._asyncQueue = document._asyncQueue;
+  }
+
+  fetch(url, { element, onLoad, onError }) {
+    if (!this._loadSubresources) {
+      return null;
+    }
+
+    const abortController = new AbortController();
+
+    // Add it to the request manager. The request manager is very old code, but it works with the contract of "has an
+    // `abort()` method". One day this whole subsystem will be refactored to use `AbortController`s natively, but for
+    // now this just happens to work.
+    //
+    // Note that we add the controller now, before calling `fetchCollected()`, so that if any interceptors or other code
+    // calls `window.close()`, the abort controller is already registered and will see the abort.
+    this._requestManager.add(abortController);
+
+    const fetchPromise = fetchCollected(this._dispatcher, {
+      url,
+      headers: { Referer: this._document.URL },
+      signal: abortController.signal,
+      element: idlUtils.wrapperForImpl(element)
+    });
+
+    const onErrorWrapped = cause => {
+      this._requestManager.remove(abortController);
+
+      // If the request was aborted, don't fire error events
+      if (cause && cause.name === "AbortError") {
+        return Promise.resolve();
+      }
+
+      if (onError) {
+        onError(cause);
+      }
+
+      fireAnEvent("error", element);
+
+      const jsomError = new Error(`Could not load ${element.localName}: "${url}"`, { cause });
+      jsomError.type = "resource-loading";
+      jsomError.url = url;
+
+      this._document._defaultView._virtualConsole.emit("jsdomError", jsomError);
+
+      return Promise.resolve();
+    };
+
+    const onLoadWrapped = response => {
+      this._requestManager.remove(abortController);
+
+      // Extract data and create a response-like object for compatibility
+      const { body: data, status, headers, url: responseURL } = response;
+      const responseObj = {
+        ok: status >= 200 && status < 300,
+        status,
+        headers: {
+          get(name) {
+            return headers[name.toLowerCase()] ?? null;
+          }
+        },
+        url: responseURL
+      };
+
+      try {
+        const result = onLoad ? onLoad(data, responseObj) : undefined;
+
+        return Promise.resolve(result)
+          .then(() => {
+            fireAnEvent("load", element);
+
+            return Promise.resolve();
+          })
+          .catch(err => {
+            return onErrorWrapped(err);
+          });
+      } catch (err) {
+        return onErrorWrapped(err);
+      }
+    };
+
+    // Create a wrapper object that can be used by the queue system
+    const request = {
+      then: (onFulfilled, onRejected) => fetchPromise.then(onFulfilled, onRejected),
+      catch: onRejected => fetchPromise.catch(onRejected)
+    };
+
+    if (element.localName === "script" && element.hasAttributeNS(null, "async")) {
+      this._asyncQueue.push(request, onLoadWrapped, onErrorWrapped, this._queue.getLastScript());
+    } else if (
+      element.localName === "script" &&
+        element.hasAttributeNS(null, "defer") &&
+        this._document.readyState !== "interactive") {
+      this._deferQueue.push(request, onLoadWrapped, onErrorWrapped, false, element);
+    } else {
+      this._queue.push(request, onLoadWrapped, onErrorWrapped, false, element);
+    }
+
+    return request;
+  }
+};

package/ui/.output/server/node_modules/jsdom/lib/jsdom/browser/resources/request-interceptor.js

@@ -0,0 +1,171 @@
+"use strict";
+const { Readable } = require("stream");
+const { sendStreamResponse } = require("./stream-handler");
+
+/**
+ * Creates a user-friendly `undici` interceptor for jsdom.
+ *
+ * This helper allows users to intercept requests using a callback that receives a `Request` object and can return a
+ * promise for a `Response` to provide a synthetic response, or a promise for `undefined` to pass through.
+ *
+ * @param {function} fn - Async callback function that receives (request, context) and can return a Response
+ * @returns {function} An undici interceptor
+ *
+ * @example
+ * const dom = new JSDOM(html, {
+ *   interceptors: [
+ *     requestInterceptor(async (request, { element }) => {
+ *       console.log(`${element?.localName || 'XHR'} requested ${request.url}`);
+ *       if (request.url.endsWith('/test.js')) {
+ *         return new Response('window.mocked = true;', {
+ *           headers: { 'Content-Type': 'application/javascript' }
+ *         });
+ *       }
+ *       // Return undefined to let the request pass through
+ *     })
+ *   ]
+ * });
+ *
+ * ## Why this doesn't use undici's DecoratorHandler pattern
+ *
+ * The standard undici interceptor pattern (see e.g. undici/lib/interceptor/dump.js) uses DecoratorHandler
+ * to wrap handler callbacks. That pattern calls `dispatch()` synchronously, then observes/modifies the
+ * request and response as they flow through the handler callbacks.
+ *
+ * This interceptor needs to support async user functions that can BLOCK the request and potentially
+ * REPLACE it with a synthetic response. This requires:
+ *
+ * 1. Waiting for the async user function BEFORE deciding whether to dispatch
+ * 2. For synthetic responses, NEVER calling dispatch() at all
+ *
+ * Since synthetic responses bypass the normal undici dispatch flow entirely, there's no underlying
+ * dispatcher (Agent/Pool) to create a real controller for us. We provide our own controller object
+ * that delegates to a Node.js Readable stream for pause/resume/abort support, following the pattern
+ * from undici/lib/interceptor/cache.js.
+ */
+module.exports = function requestInterceptor(fn) {
+  return dispatch => (options, handler) => {
+    const { element = null, url } = options.opaque || {};
+    const abortController = new AbortController();
+
+    // Create undici controller and wrapped handler using the signal handler helper.
+    // The undici controller reflects abortController.signal's state and forwards to inner undici controller.
+    const { undiciController, wrappedHandler } = createSignalHandler(handler, abortController);
+
+    // Call onRequestStart immediately to wire into the abort chain.
+    handler.onRequestStart?.(undiciController, {});
+
+    // Build Request object with our signal
+    const requestInit = {
+      method: options.method || "GET",
+      headers: options.headers,
+      signal: abortController.signal
+    };
+    if (options.body !== undefined && options.body !== null) {
+      requestInit.body = options.body;
+      requestInit.duplex = "half";
+    }
+    if (options.referrer) {
+      requestInit.referrer = options.referrer;
+    }
+    const request = new Request(url, requestInit);
+
+    new Promise(resolve => {
+      resolve(fn(request, { element }));
+    })
+      .then(response => {
+        if (response instanceof Response) {
+          // Send synthetic response without ever starting real request
+          // response.body can be null for responses with no body
+          const stream = response.body ? Readable.fromWeb(response.body) : Readable.from([]);
+          sendStreamResponse(wrappedHandler, stream, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: headersToUndici(response.headers)
+          });
+        } else if (response !== undefined) {
+          throw new TypeError("requestInterceptor callback must return undefined or a Response");
+        } else if (!abortController.signal.aborted) {
+          // Pass through to real request
+          dispatch(options, wrappedHandler);
+        }
+      })
+      .catch(error => {
+        handler.onResponseError?.(undiciController, error);
+      });
+
+    // Return true to indicate request is being handled
+    return true;
+  };
+};
+
+/**
+ * Creates an undici controller and wrapped handler that bridge an AbortController to undici's dispatch protocol.
+ *
+ * The undici controller reflects the AbortController's signal state and captures an inner undici controller
+ * (from pass-through dispatch or synthetic stream) for forwarding pause/resume/abort.
+ */
+function createSignalHandler(handler, abortController) {
+  let innerUndiciController = null;
+
+  const undiciController = {
+    abort(reason) {
+      abortController.abort(reason);
+      innerUndiciController?.abort(reason);
+    },
+    pause() {
+      innerUndiciController?.pause();
+    },
+    resume() {
+      innerUndiciController?.resume();
+    },
+    get paused() {
+      return innerUndiciController?.paused ?? false;
+    },
+    get aborted() {
+      return abortController.signal.aborted;
+    },
+    get reason() {
+      return abortController.signal.reason;
+    }
+  };
+
+  const wrappedHandler = {
+    onRequestStart(controller) {
+      innerUndiciController = controller;
+    },
+    onRequestUpgrade(...args) {
+      handler.onRequestUpgrade?.(...args);
+    },
+    onResponseStart(...args) {
+      handler.onResponseStart?.(...args);
+    },
+    onResponseData(...args) {
+      handler.onResponseData?.(...args);
+    },
+    onResponseEnd(...args) {
+      handler.onResponseEnd?.(...args);
+    },
+    onResponseError(...args) {
+      handler.onResponseError?.(...args);
+    }
+  };
+
+  return { undiciController, wrappedHandler };
+}
+
+/**
+ * Converts a Headers object to the format undici expects.
+ * Handles multiple Set-Cookie headers via getSetCookie().
+ */
+function headersToUndici(headers) {
+  const result = {};
+  for (const [key, value] of headers) {
+    result[key] = value;
+  }
+  const cookies = headers.getSetCookie();
+  if (cookies.length > 0) {
+    result["set-cookie"] = cookies;
+  }
+  return result;
+}

package/ui/.output/server/node_modules/jsdom/lib/jsdom/browser/resources/request-manager.js

@@ -0,0 +1,33 @@
+"use strict";
+
+/**
+ * Manage all the request and it is able to abort
+ * all pending request.
+ */
+module.exports = class RequestManager {
+  constructor() {
+    this.openedRequests = [];
+  }
+
+  add(req) {
+    this.openedRequests.push(req);
+  }
+
+  remove(req) {
+    const idx = this.openedRequests.indexOf(req);
+    if (idx !== -1) {
+      this.openedRequests.splice(idx, 1);
+    }
+  }
+
+  close() {
+    for (const openedRequest of this.openedRequests) {
+      openedRequest.abort();
+    }
+    this.openedRequests = [];
+  }
+
+  size() {
+    return this.openedRequests.length;
+  }
+};

package/ui/.output/server/node_modules/jsdom/lib/jsdom/browser/resources/resource-queue.js

@@ -0,0 +1,142 @@
+"use strict";
+
+/**
+ * Queue for all the resources to be download except async scripts.
+ * Async scripts have their own queue AsyncResourceQueue.
+ */
+module.exports = class ResourceQueue {
+  constructor({ paused, asyncQueue } = {}) {
+    this.paused = Boolean(paused);
+    this._asyncQueue = asyncQueue;
+  }
+
+  getLastScript() {
+    let head = this.tail;
+
+    while (head) {
+      if (head.isScript) {
+        return head;
+      }
+      head = head.prev;
+    }
+
+    return null;
+  }
+
+  _moreScripts() {
+    let found = false;
+
+    let head = this.tail;
+    while (head && !found) {
+      found = head.isScript;
+      head = head.prev;
+    }
+
+    return found;
+  }
+
+  _notify() {
+    if (this._listener) {
+      this._listener();
+    }
+  }
+
+  setListener(listener) {
+    this._listener = listener;
+  }
+
+  push(request, onLoad, onError, keepLast, element) {
+    const isScript = element ? element.localName === "script" : false;
+
+    if (!request) {
+      if (isScript && !this._moreScripts()) {
+        return onLoad();
+      }
+
+      request = Promise.resolve();
+    }
+    const q = this;
+    const item = {
+      isScript,
+      err: null,
+      element,
+      fired: false,
+      data: null,
+      keepLast,
+      prev: q.tail,
+      check() {
+        if (!q.paused && !this.prev && this.fired) {
+          let promise;
+
+          if (this.err && onError) {
+            promise = onError(this.err);
+          }
+
+          if (!this.err && onLoad) {
+            promise = onLoad(this.data);
+          }
+
+          Promise.resolve(promise)
+            .then(() => {
+              if (this.next) {
+                this.next.prev = null;
+                this.next.check();
+              } else { // q.tail===this
+                q.tail = null;
+                q._notify();
+              }
+
+              this.finished = true;
+
+              if (q._asyncQueue) {
+                q._asyncQueue.notifyItem(this);
+              }
+            });
+        }
+      }
+    };
+    if (q.tail) {
+      if (q.tail.keepLast) {
+        // if the tail is the load event in document and we receive a new element to load
+        // we should add this new request before the load event.
+        if (q.tail.prev) {
+          q.tail.prev.next = item;
+        }
+        item.prev = q.tail.prev;
+        q.tail.prev = item;
+        item.next = q.tail;
+      } else {
+        q.tail.next = item;
+        q.tail = item;
+      }
+    } else {
+      q.tail = item;
+    }
+    return request
+      .then(data => {
+        item.fired = 1;
+        item.data = data;
+        item.check();
+      })
+      .catch(err => {
+        item.fired = true;
+        item.err = err;
+        item.check();
+      });
+  }
+
+  resume() {
+    if (!this.paused) {
+      return;
+    }
+    this.paused = false;
+
+    let head = this.tail;
+    while (head && head.prev) {
+      head = head.prev;
+    }
+    if (head) {
+      head.check();
+    }
+  }
+};

package/ui/.output/server/node_modules/jsdom/lib/jsdom/browser/resources/stream-handler.js

@@ -0,0 +1,89 @@
+"use strict";
+
+/**
+ * Sends a response to an undici handler by streaming data from a Node.js Readable stream.
+ *
+ * ## Why this exists
+ *
+ * undici's new handler API (onRequestStart, onResponseStart, onResponseData, onResponseEnd, onResponseError)
+ * requires a "controller" object with pause/resume/abort methods. When responses flow through undici's
+ * normal network stack, undici provides this controller. But when we generate responses ourselves
+ * (e.g., for file: URLs, data: URLs, or synthetic responses from interceptors), we need to provide
+ * our own controller.
+ *
+ * This helper creates a controller backed by a Node.js Readable stream, giving callers proper
+ * pause/resume and abort support. It follows the pattern from undici/lib/interceptor/cache.js.
+ *
+ * ## Usage
+ *
+ * ```javascript
+ * const stream = fs.createReadStream(filePath);
+ * // or: const stream = Readable.from(buffer);
+ * // or: const stream = Readable.fromWeb(response.body);
+ *
+ * sendStreamResponse(handler, stream, {
+ *   status: 200,
+ *   statusText: "OK",
+ *   headers: { "content-type": "text/plain" },
+ *   context: { history: ["file:///path/to/file"] }
+ * });
+ * ```
+ *
+ * The function handles all stream events and translates them to handler callbacks.
+ * If the stream is destroyed (e.g., via controller.abort()), pending operations are cancelled.
+ *
+ * @param {object} handler - undici handler with new API methods (onRequestStart, onResponseStart, etc.)
+ * @param {Readable} stream - Node.js Readable stream containing the response body
+ * @param {object} options - Response metadata
+ * @param {number} options.status - HTTP status code
+ * @param {string} [options.statusText] - HTTP status text (default: "")
+ * @param {object} [options.headers] - Response headers as {name: value} object (default: {})
+ * @param {object} [options.context] - Context object passed to onRequestStart (default: {})
+ */
+function sendStreamResponse(handler, stream, { status, statusText = "", headers = {}, context = {} }) {
+  const controller = {
+    resume() {
+      stream.resume();
+    },
+    pause() {
+      stream.pause();
+    },
+    get paused() {
+      return stream.isPaused();
+    },
+    get aborted() {
+      return stream.errored !== null;
+    },
+    get reason() {
+      return stream.errored;
+    },
+    abort(reason) {
+      stream.destroy(reason);
+    }
+  };
+
+  stream
+    .on("error", err => {
+      if (!stream.readableEnded) {
+        handler.onResponseError?.(controller, err);
+      }
+    })
+    .on("close", () => {
+      if (!stream.errored) {
+        handler.onResponseEnd?.(controller, {});
+      }
+    })
+    .on("data", chunk => {
+      handler.onResponseData?.(controller, chunk);
+    });
+
+  handler.onRequestStart?.(controller, context);
+
+  if (stream.destroyed) {
+    return;
+  }
+
+  handler.onResponseStart?.(controller, status, headers, statusText);
+}
+
+module.exports = { sendStreamResponse };