patchright-core 1.52.5 → 1.55.1

package/lib/server/dispatchers/localUtilsDispatcher.js

@@ -37,7 +37,6 @@ var localUtils = __toESM(require("../localUtils"));
 var import_userAgent = require("../utils/userAgent");
 var import_deviceDescriptors = require("../deviceDescriptors");
 var import_jsonPipeDispatcher = require("../dispatchers/jsonPipeDispatcher");
-var import_progress = require("../progress");
 var import_socksInterceptor = require("../socksInterceptor");
 var import_transport = require("../transport");
 var import_network = require("../utils/network");
@@ -45,6 +44,7 @@ var import_urlMatch = require("../../utils/isomorphic/urlMatch");
 class LocalUtilsDispatcher extends import_dispatcher.Dispatcher {
   constructor(scope, playwright) {
     const localUtils2 = new import_instrumentation.SdkObject(playwright, "localUtils", "localUtils");
+    localUtils2.logName = "browser";
     const deviceDescriptors = Object.entries(import_deviceDescriptors.deviceDescriptors).map(([name, descriptor]) => ({ name, descriptor }));
     super(scope, localUtils2, "LocalUtils", {
       deviceDescriptors
@@ -53,70 +53,66 @@ class LocalUtilsDispatcher extends import_dispatcher.Dispatcher {
     this._stackSessions = /* @__PURE__ */ new Map();
     this._type_LocalUtils = true;
   }
-  async zip(params) {
-    return await localUtils.zip(this._stackSessions, params);
+  async zip(params, progress) {
+    return await localUtils.zip(progress, this._stackSessions, params);
   }
-  async harOpen(params, metadata) {
-    return await localUtils.harOpen(this._harBackends, params);
+  async harOpen(params, progress) {
+    return await localUtils.harOpen(progress, this._harBackends, params);
   }
-  async harLookup(params, metadata) {
-    return await localUtils.harLookup(this._harBackends, params);
+  async harLookup(params, progress) {
+    return await localUtils.harLookup(progress, this._harBackends, params);
   }
-  async harClose(params, metadata) {
-    return await localUtils.harClose(this._harBackends, params);
+  async harClose(params, progress) {
+    localUtils.harClose(this._harBackends, params);
   }
-  async harUnzip(params, metadata) {
-    return await localUtils.harUnzip(params);
+  async harUnzip(params, progress) {
+    return await localUtils.harUnzip(progress, params);
   }
-  async tracingStarted(params, metadata) {
-    return await localUtils.tracingStarted(this._stackSessions, params);
+  async tracingStarted(params, progress) {
+    return await localUtils.tracingStarted(progress, this._stackSessions, params);
   }
-  async traceDiscarded(params, metadata) {
-    return await localUtils.traceDiscarded(this._stackSessions, params);
+  async traceDiscarded(params, progress) {
+    return await localUtils.traceDiscarded(progress, this._stackSessions, params);
   }
-  async addStackToTracingNoReply(params, metadata) {
-    return await localUtils.addStackToTracingNoReply(this._stackSessions, params);
+  async addStackToTracingNoReply(params, progress) {
+    localUtils.addStackToTracingNoReply(this._stackSessions, params);
   }
-  async connect(params, metadata) {
-    const controller = new import_progress.ProgressController(metadata, this._object);
-    controller.setLogName("browser");
-    return await controller.run(async (progress) => {
-      const wsHeaders = {
-        "User-Agent": (0, import_userAgent.getUserAgent)(),
-        "x-playwright-proxy": params.exposeNetwork ?? "",
-        ...params.headers
+  async connect(params, progress) {
+    const wsHeaders = {
+      "User-Agent": (0, import_userAgent.getUserAgent)(),
+      "x-playwright-proxy": params.exposeNetwork ?? "",
+      ...params.headers
+    };
+    const wsEndpoint = await urlToWSEndpoint(progress, params.wsEndpoint);
+    const transport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint, { headers: wsHeaders, followRedirects: true, debugLogHeader: "x-playwright-debug-log" });
+    const socksInterceptor = new import_socksInterceptor.SocksInterceptor(transport, params.exposeNetwork, params.socksProxyRedirectPortForTest);
+    const pipe = new import_jsonPipeDispatcher.JsonPipeDispatcher(this);
+    transport.onmessage = (json) => {
+      if (socksInterceptor.interceptMessage(json))
+        return;
+      const cb = () => {
+        try {
+          pipe.dispatch(json);
+        } catch (e) {
+          transport.close();
+        }
       };
-      const wsEndpoint = await urlToWSEndpoint(progress, params.wsEndpoint);
-      const transport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint, { headers: wsHeaders, followRedirects: true, debugLogHeader: "x-playwright-debug-log" });
-      const socksInterceptor = new import_socksInterceptor.SocksInterceptor(transport, params.exposeNetwork, params.socksProxyRedirectPortForTest);
-      const pipe = new import_jsonPipeDispatcher.JsonPipeDispatcher(this);
-      transport.onmessage = (json) => {
-        if (socksInterceptor.interceptMessage(json))
-          return;
-        const cb = () => {
-          try {
-            pipe.dispatch(json);
-          } catch (e) {
-            transport.close();
-          }
-        };
-        if (params.slowMo)
-          setTimeout(cb, params.slowMo);
-        else
-          cb();
-      };
-      pipe.on("message", (message) => {
-        transport.send(message);
-      });
-      transport.onclose = (reason) => {
-        socksInterceptor?.cleanup();
-        pipe.wasClosed(reason);
-      };
-      pipe.on("close", () => transport.close());
-      return { pipe, headers: transport.headers };
-    }, params.timeout || 0);
+      if (params.slowMo)
+        setTimeout(cb, params.slowMo);
+      else
+        cb();
+    };
+    pipe.on("message", (message) => {
+      transport.send(message);
+    });
+    transport.onclose = (reason) => {
+      socksInterceptor?.cleanup();
+      pipe.wasClosed(reason);
+    };
+    pipe.on("close", () => transport.close());
+    return { pipe, headers: transport.headers };
   }
-  async globToRegex(params, metadata) {
+  async globToRegex(params, progress) {
     const regex = (0, import_urlMatch.resolveGlobToRegexPattern)(params.baseURL, params.glob, params.webSocketUrl);
     return { regex };
   }
@@ -124,21 +120,19 @@ class LocalUtilsDispatcher extends import_dispatcher.Dispatcher {
 async function urlToWSEndpoint(progress, endpointURL) {
   if (endpointURL.startsWith("ws"))
     return endpointURL;
-  progress?.log(`<ws preparing> retrieving websocket url from ${endpointURL}`);
+  progress.log(`<ws preparing> retrieving websocket url from ${endpointURL}`);
   const fetchUrl = new URL(endpointURL);
   if (!fetchUrl.pathname.endsWith("/"))
     fetchUrl.pathname += "/";
   fetchUrl.pathname += "json";
-  const json = await (0, import_network.fetchData)({
+  const json = await (0, import_network.fetchData)(progress, {
     url: fetchUrl.toString(),
     method: "GET",
-    timeout: progress?.timeUntilDeadline() ?? 3e4,
     headers: { "User-Agent": (0, import_userAgent.getUserAgent)() }
   }, async (params, response) => {
     return new Error(`Unexpected status ${response.statusCode} when connecting to ${fetchUrl.toString()}.
 This does not look like a Playwright server, try connecting via ws://.`);
   });
-  progress?.throwIfAborted();
   const wsUrl = new URL(endpointURL);
   let wsEndpointPath = JSON.parse(json).wsEndpointPath;
   if (wsEndpointPath.startsWith("/"))

package/lib/server/dispatchers/networkDispatchers.js

@@ -32,7 +32,7 @@ var import_pageDispatcher = require("./pageDispatcher");
 var import_tracingDispatcher = require("./tracingDispatcher");
 class RequestDispatcher extends import_dispatcher.Dispatcher {
   static from(scope, request) {
-    const result = (0, import_dispatcher.existingDispatcher)(request);
+    const result = scope.connection.existingDispatcher(request);
     return result || new RequestDispatcher(scope, request);
   }
   static fromNullable(scope, request) {
@@ -42,7 +42,7 @@ class RequestDispatcher extends import_dispatcher.Dispatcher {
     const postData = request.postDataBuffer();
     const frame = request.frame();
     const page = request.frame()?._page;
-    const pageDispatcher = page ? (0, import_dispatcher.existingDispatcher)(page) : null;
+    const pageDispatcher = page ? scope.connection.existingDispatcher(page) : null;
     const frameDispatcher = frame ? import_frameDispatcher.FrameDispatcher.from(scope, frame) : null;
     super(pageDispatcher || frameDispatcher || scope, request, "Request", {
       frame: import_frameDispatcher.FrameDispatcher.fromNullable(scope, request.frame()),
@@ -58,11 +58,11 @@ class RequestDispatcher extends import_dispatcher.Dispatcher {
     this._type_Request = true;
     this._browserContextDispatcher = scope;
   }
-  async rawRequestHeaders(params) {
-    return { headers: await this._object.rawRequestHeaders() };
+  async rawRequestHeaders(params, progress) {
+    return { headers: await progress.race(this._object.rawRequestHeaders()) };
   }
-  async response() {
-    return { response: ResponseDispatcher.fromNullable(this._browserContextDispatcher, await this._object.response()) };
+  async response(params, progress) {
+    return { response: ResponseDispatcher.fromNullable(this._browserContextDispatcher, await progress.race(this._object.response())) };
   }
 }
 class ResponseDispatcher extends import_dispatcher.Dispatcher {
@@ -80,27 +80,27 @@ class ResponseDispatcher extends import_dispatcher.Dispatcher {
     this._type_Response = true;
   }
   static from(scope, response) {
-    const result = (0, import_dispatcher.existingDispatcher)(response);
+    const result = scope.connection.existingDispatcher(response);
     const requestDispatcher = RequestDispatcher.from(scope, response.request());
     return result || new ResponseDispatcher(requestDispatcher, response);
   }
   static fromNullable(scope, response) {
     return response ? ResponseDispatcher.from(scope, response) : void 0;
   }
-  async body() {
-    return { binary: await this._object.body() };
+  async body(params, progress) {
+    return { binary: await progress.race(this._object.body()) };
   }
-  async securityDetails() {
-    return { value: await this._object.securityDetails() || void 0 };
+  async securityDetails(params, progress) {
+    return { value: await progress.race(this._object.securityDetails()) || void 0 };
   }
-  async serverAddr() {
-    return { value: await this._object.serverAddr() || void 0 };
+  async serverAddr(params, progress) {
+    return { value: await progress.race(this._object.serverAddr()) || void 0 };
   }
-  async rawResponseHeaders(params) {
-    return { headers: await this._object.rawResponseHeaders() };
+  async rawResponseHeaders(params, progress) {
+    return { headers: await progress.race(this._object.rawResponseHeaders()) };
   }
-  async sizes(params) {
-    return { sizes: await this._object.sizes() };
+  async sizes(params, progress) {
+    return { sizes: await progress.race(this._object.sizes()) };
   }
 }
 class RouteDispatcher extends import_dispatcher.Dispatcher {
@@ -110,12 +110,15 @@ class RouteDispatcher extends import_dispatcher.Dispatcher {
       request: scope
     });
     this._type_Route = true;
+    this._handled = false;
   }
-  static from(scope, route) {
-    const result = (0, import_dispatcher.existingDispatcher)(route);
-    return result || new RouteDispatcher(scope, route);
+  _checkNotHandled() {
+    if (this._handled)
+      throw new Error("Route is already handled!");
+    this._handled = true;
   }
-  async continue(params, metadata) {
+  async continue(params, progress) {
+    this._checkNotHandled();
     await this._object.continue({
       url: params.url,
       method: params.method,
@@ -124,14 +127,17 @@ class RouteDispatcher extends import_dispatcher.Dispatcher {
       isFallback: params.isFallback
     });
   }
-  async fulfill(params, metadata) {
+  async fulfill(params, progress) {
+    this._checkNotHandled();
     await this._object.fulfill(params);
   }
-  async abort(params, metadata) {
+  async abort(params, progress) {
+    this._checkNotHandled();
     await this._object.abort(params.errorCode || "failed");
   }
-  async redirectNavigationRequest(params) {
-    await this._object.redirectNavigationRequest(params.url);
+  async redirectNavigationRequest(params, progress) {
+    this._checkNotHandled();
+    this._object.redirectNavigationRequest(params.url);
   }
 }
 class WebSocketDispatcher extends import_dispatcher.Dispatcher {
@@ -157,22 +163,22 @@ class APIRequestContextDispatcher extends import_dispatcher.Dispatcher {
     this.adopt(tracing);
   }
   static from(scope, request) {
-    const result = (0, import_dispatcher.existingDispatcher)(request);
+    const result = scope.connection.existingDispatcher(request);
     return result || new APIRequestContextDispatcher(scope, request);
   }
   static fromNullable(scope, request) {
     return request ? APIRequestContextDispatcher.from(scope, request) : void 0;
   }
-  async storageState(params) {
-    return this._object.storageState(params.indexedDB);
+  async storageState(params, progress) {
+    return await this._object.storageState(progress, params.indexedDB);
   }
-  async dispose(params, metadata) {
-    metadata.potentiallyClosesScope = true;
+  async dispose(params, progress) {
+    progress.metadata.potentiallyClosesScope = true;
     await this._object.dispose(params);
     this._dispose();
   }
-  async fetch(params, metadata) {
-    const fetchResponse = await this._object.fetch(params, metadata);
+  async fetch(params, progress) {
+    const fetchResponse = await this._object.fetch(progress, params);
     return {
       response: {
         url: fetchResponse.url,
@@ -183,14 +189,14 @@ class APIRequestContextDispatcher extends import_dispatcher.Dispatcher {
       }
     };
   }
-  async fetchResponseBody(params) {
+  async fetchResponseBody(params, progress) {
     return { binary: this._object.fetchResponses.get(params.fetchUid) };
   }
-  async fetchLog(params) {
+  async fetchLog(params, progress) {
     const log = this._object.fetchLog.get(params.fetchUid) || [];
     return { log };
   }
-  async disposeAPIResponse(params) {
+  async disposeAPIResponse(params, progress) {
     this._object.disposeResponse(params.fetchUid);
   }
 }