@grabbit-labs/dynafetch 0.2.3 → 0.2.4

package/dist/index.js

@@ -325,7 +325,8 @@ async function withDynafetchSession(options, run) {
   try {
     return await sessionStore.run({ sessionId: session.sessionId }, run);
   } finally {
-    callWorker("closeSession", { sessionId: session.sessionId }).catch(() => {
+    const closeTimeoutMs = Math.min(resolveRpcTimeoutMs(options), 5e3);
+    await callWorker("closeSession", { sessionId: session.sessionId }, closeTimeoutMs).catch(() => {
     });
     transport.release();
   }
@@ -876,6 +877,7 @@ var Executor = class {
     this.esbuildModule = null;
     this.originalGlobalMessageChannel = void 0;
     this.originalGlobalMessagePort = void 0;
+    this.activeTimerHandles = /* @__PURE__ */ new Set();
     // Simple telemetry counters (useful for debugging).
     this.telemetry_stubbed = 0;
     this.telemetry_proxy = 0;
@@ -977,6 +979,23 @@ var Executor = class {
       }
     }
   }
+  clearTrackedTimers(window) {
+    for (const handle of this.activeTimerHandles) {
+      try {
+        window.clearTimeout?.(handle);
+      } catch {
+      }
+      try {
+        window.clearInterval?.(handle);
+      } catch {
+      }
+      try {
+        handle?.unref?.();
+      } catch {
+      }
+    }
+    this.activeTimerHandles.clear();
+  }
   applyDefaults(quiescence, moduleWaitMsOverride) {
     const hardMaxCap = this.clampMs(Number(process.env.PHANTOM_QUIESCENCE_MAX_CAP_MS ?? 8e3), 500, 6e4);
     const minWaitMs = this.clampMs(quiescence?.minWaitMs ?? 75, 0, 1e4);
@@ -1414,14 +1433,66 @@ var Executor = class {
       };
     }
     const g = globalThis;
-    if (!window.Headers && g.Headers) window.Headers = g.Headers;
-    if (!window.Request && g.Request) window.Request = g.Request;
-    if (!window.Response && g.Response) window.Response = g.Response;
-    if (!window.AbortController && g.AbortController) window.AbortController = g.AbortController;
-    if (!window.AbortSignal && g.AbortSignal) window.AbortSignal = g.AbortSignal;
+    if (g.Headers) window.Headers = g.Headers;
+    if (g.Response) window.Response = g.Response;
+    if (g.AbortController) window.AbortController = g.AbortController;
+    if (g.AbortSignal) window.AbortSignal = g.AbortSignal;
     if (!window.TextEncoder && g.TextEncoder) window.TextEncoder = g.TextEncoder;
     if (!window.TextDecoder && g.TextDecoder) window.TextDecoder = g.TextDecoder;
     if (!window.structuredClone && g.structuredClone) window.structuredClone = g.structuredClone.bind(g);
+    const normalizeUrlForRequest = (value) => {
+      if (typeof value !== "string") return value;
+      try {
+        return new URL(value, window.location.href).toString();
+      } catch {
+        return value;
+      }
+    };
+    const normalizeAbortSignalForRequest = (signal) => {
+      if (!signal || !g.AbortController || !g.AbortSignal) return signal;
+      if (signal instanceof g.AbortSignal) return signal;
+      if (typeof signal.aborted !== "boolean") return void 0;
+      const controller = new g.AbortController();
+      if (signal.aborted) {
+        try {
+          controller.abort(signal.reason);
+        } catch {
+          controller.abort();
+        }
+        return controller.signal;
+      }
+      if (typeof signal.addEventListener === "function") {
+        try {
+          signal.addEventListener("abort", () => {
+            try {
+              controller.abort(signal.reason);
+            } catch {
+              controller.abort();
+            }
+          }, { once: true });
+        } catch {
+        }
+      }
+      return controller.signal;
+    };
+    if (g.Request) {
+      const NativeRequest = g.Request;
+      const RequestShim = class Request extends NativeRequest {
+        constructor(input, init) {
+          const normalizedInput = typeof input === "string" ? normalizeUrlForRequest(input) : input instanceof URL ? normalizeUrlForRequest(input.toString()) : input;
+          const normalizedInit = init && typeof init === "object" ? {
+            ...init,
+            signal: normalizeAbortSignalForRequest(init.signal)
+          } : init;
+          super(normalizedInput, normalizedInit);
+        }
+      };
+      try {
+        Object.setPrototypeOf(RequestShim, NativeRequest);
+      } catch {
+      }
+      window.Request = RequestShim;
+    }
     const makeStorage = () => {
       const store = /* @__PURE__ */ new Map();
       return {
@@ -1620,8 +1691,41 @@ var Executor = class {
     };
     const _setTimeout = window.setTimeout?.bind(window);
     const _setInterval = window.setInterval?.bind(window);
-    if (_setTimeout) window.setTimeout = (cb, ms, ...rest) => _setTimeout(wrapCb(cb), ms, ...rest);
-    if (_setInterval) window.setInterval = (cb, ms, ...rest) => _setInterval(wrapCb(cb), ms, ...rest);
+    const _clearTimeout = window.clearTimeout?.bind(window);
+    const _clearInterval = window.clearInterval?.bind(window);
+    if (_setTimeout) {
+      window.setTimeout = (cb, ms, ...rest) => {
+        let handle;
+        const wrapped = wrapCb((...args) => {
+          this.activeTimerHandles.delete(handle);
+          return typeof cb === "function" ? cb(...args) : cb;
+        });
+        handle = _setTimeout(wrapped, ms, ...rest);
+        this.activeTimerHandles.add(handle);
+        handle?.unref?.();
+        return handle;
+      };
+    }
+    if (_setInterval) {
+      window.setInterval = (cb, ms, ...rest) => {
+        const handle = _setInterval(wrapCb(cb), ms, ...rest);
+        this.activeTimerHandles.add(handle);
+        handle?.unref?.();
+        return handle;
+      };
+    }
+    if (_clearTimeout) {
+      window.clearTimeout = (handle) => {
+        this.activeTimerHandles.delete(handle);
+        return _clearTimeout(handle);
+      };
+    }
+    if (_clearInterval) {
+      window.clearInterval = (handle) => {
+        this.activeTimerHandles.delete(handle);
+        return _clearInterval(handle);
+      };
+    }
     if (window.queueMicrotask) {
       const _q = window.queueMicrotask.bind(window);
       window.queueMicrotask = (cb) => _q(wrapCb(cb));
@@ -1731,7 +1835,7 @@ var Executor = class {
     try {
       const virtualConsole = new VirtualConsole();
       virtualConsole.on("log", (...args) => log("[JSDOM Log]", ...args));
-      virtualConsole.on("error", (...args) => console.error("[JSDOM Error]", ...args));
+      virtualConsole.on("error", (...args) => warn("[JSDOM Error]", ...args));
       virtualConsole.on("warn", (...args) => warn("[JSDOM Warn]", ...args));
       const cookieJar = new CookieJar();
       this.harvestData.cookies.forEach((c) => {
@@ -2139,10 +2243,6 @@ var Executor = class {
       log(`[Executor] Quiescence reached in ${Date.now() - quiescenceStart}ms ${reason}`);
       const renderedHtml = this.serializeDocument(window);
       this.windowClosed = true;
-      try {
-        window.close();
-      } catch {
-      }
       const result = {
         logs: this.logs,
         matchedRequests: this.earlyMatches,
@@ -2153,6 +2253,7 @@ var Executor = class {
       };
       const shutdownGraceMs = this.clampMs(Number(process.env.PHANTOM_SHUTDOWN_GRACE_MS ?? 50), 10, 5e3);
       await new Promise((r) => setTimeout(r, shutdownGraceMs));
+      this.clearTrackedTimers(window);
       this.unrefNewMessagePorts(initialActiveHandles);
       return result;
     } finally {
@@ -2259,6 +2360,12 @@ var Executor = class {
     };
     window.__phantom = {
       fetch: async (input, opts = {}) => {
+        if (that.windowClosed) {
+          return new (window.Response || global.Response)("", {
+            status: 200,
+            headers: toSafeResponseHeaders({})
+          });
+        }
         const norm = await normalizeFetchInput(input, opts);
         const start = Date.now();
         const headers = {
@@ -2336,6 +2443,7 @@ var Executor = class {
         }
       },
       dynamicImport: async (url) => {
+        if (that.windowClosed) return {};
         const fullUrl = new URL(url, window.location.href).toString();
         const start = Date.now();
         const logEntry = {
@@ -2448,6 +2556,12 @@ var Executor = class {
           this.onloadend?.({ type: "loadend" });
         }
         async send(body) {
+          if (that.windowClosed) {
+            this.readyState = 4;
+            this.status = 0;
+            this.onloadend?.({ type: "loadend" });
+            return;
+          }
           const start = Date.now();
           const headers = {
             "User-Agent": window.navigator.userAgent,