patchright-core 1.52.4 → 1.55.0

package/lib/server/localUtils.js

@@ -49,7 +49,7 @@ var import_zipBundle = require("../zipBundle");
 var import_traceUtils = require("../utils/isomorphic/traceUtils");
 var import_assert = require("../utils/isomorphic/assert");
 var import_fileUtils = require("./utils/fileUtils");
-async function zip(stackSessions, params) {
+async function zip(progress, stackSessions, params) {
   const promise = new import_manualPromise.ManualPromise();
   const zipFile = new import_zipBundle.yazl.ZipFile();
   zipFile.on("error", (error) => promise.reject(error));
@@ -64,7 +64,7 @@ async function zip(stackSessions, params) {
     addFile(entry.value, entry.name);
   const stackSession = params.stacksId ? stackSessions.get(params.stacksId) : void 0;
   if (stackSession?.callStacks.length) {
-    await stackSession.writer;
+    await progress.race(stackSession.writer);
     if (process.env.PW_LIVE_TRACE_STACKS) {
       zipFile.addFile(stackSession.file, "trace.stacks");
     } else {
@@ -84,16 +84,16 @@ async function zip(stackSessions, params) {
       addFile(sourceFile, "resources/src@" + await (0, import_crypto.calculateSha1)(sourceFile) + ".txt");
   }
   if (params.mode === "write") {
-    await import_fs.default.promises.mkdir(import_path.default.dirname(params.zipFile), { recursive: true });
+    await progress.race(import_fs.default.promises.mkdir(import_path.default.dirname(params.zipFile), { recursive: true }));
     zipFile.end(void 0, () => {
       zipFile.outputStream.pipe(import_fs.default.createWriteStream(params.zipFile)).on("close", () => promise.resolve()).on("error", (error) => promise.reject(error));
     });
-    await promise;
-    await deleteStackSession(stackSessions, params.stacksId);
+    await progress.race(promise);
+    await deleteStackSession(progress, stackSessions, params.stacksId);
     return;
   }
   const tempFile = params.zipFile + ".tmp";
-  await import_fs.default.promises.rename(params.zipFile, tempFile);
+  await progress.race(import_fs.default.promises.rename(params.zipFile, tempFile));
   import_zipBundle.yauzl.open(tempFile, (err, inZipFile) => {
     if (err) {
       promise.reject(err);
@@ -120,74 +120,81 @@ async function zip(stackSessions, params) {
       });
     });
   });
-  await promise;
-  await deleteStackSession(stackSessions, params.stacksId);
+  await progress.race(promise);
+  await deleteStackSession(progress, stackSessions, params.stacksId);
 }
-async function deleteStackSession(stackSessions, stacksId) {
+async function deleteStackSession(progress, stackSessions, stacksId) {
   const session = stacksId ? stackSessions.get(stacksId) : void 0;
   if (!session)
     return;
-  await session.writer;
-  if (session.tmpDir)
-    await (0, import_fileUtils.removeFolders)([session.tmpDir]);
   stackSessions.delete(stacksId);
+  if (session.tmpDir)
+    await progress.race((0, import_fileUtils.removeFolders)([session.tmpDir]));
 }
-async function harOpen(harBackends, params) {
+async function harOpen(progress, harBackends, params) {
   let harBackend;
   if (params.file.endsWith(".zip")) {
     const zipFile = new import_zipFile.ZipFile(params.file);
-    const entryNames = await zipFile.entries();
-    const harEntryName = entryNames.find((e) => e.endsWith(".har"));
-    if (!harEntryName)
-      return { error: "Specified archive does not have a .har file" };
-    const har = await zipFile.read(harEntryName);
-    const harFile = JSON.parse(har.toString());
-    harBackend = new import_harBackend.HarBackend(harFile, null, zipFile);
+    try {
+      const entryNames = await progress.race(zipFile.entries());
+      const harEntryName = entryNames.find((e) => e.endsWith(".har"));
+      if (!harEntryName)
+        return { error: "Specified archive does not have a .har file" };
+      const har = await progress.race(zipFile.read(harEntryName));
+      const harFile = JSON.parse(har.toString());
+      harBackend = new import_harBackend.HarBackend(harFile, null, zipFile);
+    } catch (error) {
+      zipFile.close();
+      throw error;
+    }
   } else {
-    const harFile = JSON.parse(await import_fs.default.promises.readFile(params.file, "utf-8"));
+    const harFile = JSON.parse(await progress.race(import_fs.default.promises.readFile(params.file, "utf-8")));
     harBackend = new import_harBackend.HarBackend(harFile, import_path.default.dirname(params.file), null);
   }
   harBackends.set(harBackend.id, harBackend);
   return { harId: harBackend.id };
 }
-async function harLookup(harBackends, params) {
+async function harLookup(progress, harBackends, params) {
   const harBackend = harBackends.get(params.harId);
   if (!harBackend)
     return { action: "error", message: `Internal error: har was not opened` };
-  return await harBackend.lookup(params.url, params.method, params.headers, params.postData, params.isNavigationRequest);
+  return await progress.race(harBackend.lookup(params.url, params.method, params.headers, params.postData, params.isNavigationRequest));
 }
-async function harClose(harBackends, params) {
+function harClose(harBackends, params) {
   const harBackend = harBackends.get(params.harId);
   if (harBackend) {
     harBackends.delete(harBackend.id);
     harBackend.dispose();
   }
 }
-async function harUnzip(params) {
+async function harUnzip(progress, params) {
   const dir = import_path.default.dirname(params.zipFile);
   const zipFile = new import_zipFile.ZipFile(params.zipFile);
-  for (const entry of await zipFile.entries()) {
-    const buffer = await zipFile.read(entry);
-    if (entry === "har.har")
-      await import_fs.default.promises.writeFile(params.harFile, buffer);
-    else
-      await import_fs.default.promises.writeFile(import_path.default.join(dir, entry), buffer);
+  try {
+    for (const entry of await progress.race(zipFile.entries())) {
+      const buffer = await progress.race(zipFile.read(entry));
+      if (entry === "har.har")
+        await progress.race(import_fs.default.promises.writeFile(params.harFile, buffer));
+      else
+        await progress.race(import_fs.default.promises.writeFile(import_path.default.join(dir, entry), buffer));
+    }
+    await progress.race(import_fs.default.promises.unlink(params.zipFile));
+  } finally {
+    zipFile.close();
   }
-  zipFile.close();
-  await import_fs.default.promises.unlink(params.zipFile);
 }
-async function tracingStarted(stackSessions, params) {
+async function tracingStarted(progress, stackSessions, params) {
   let tmpDir = void 0;
   if (!params.tracesDir)
-    tmpDir = await import_fs.default.promises.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "playwright-tracing-"));
+    tmpDir = await progress.race(import_fs.default.promises.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "playwright-tracing-")));
   const traceStacksFile = import_path.default.join(params.tracesDir || tmpDir, params.traceName + ".stacks");
   stackSessions.set(traceStacksFile, { callStacks: [], file: traceStacksFile, writer: Promise.resolve(), tmpDir });
   return { stacksId: traceStacksFile };
 }
-async function traceDiscarded(stackSessions, params) {
-  await deleteStackSession(stackSessions, params.stacksId);
+async function traceDiscarded(progress, stackSessions, params) {
+  await deleteStackSession(progress, stackSessions, params.stacksId);
 }
-async function addStackToTracingNoReply(stackSessions, params) {
+function addStackToTracingNoReply(stackSessions, params) {
   for (const session of stackSessions.values()) {
     session.callStacks.push(params.callData);
     if (process.env.PW_LIVE_TRACE_STACKS) {

package/lib/server/network.js

@@ -23,6 +23,7 @@ __export(network_exports, {
   Route: () => Route,
   WebSocket: () => WebSocket,
   filterCookies: () => filterCookies,
+  isLocalHostname: () => isLocalHostname,
   kMaxCookieExpiresDateInSeconds: () => kMaxCookieExpiresDateInSeconds,
   mergeHeaders: () => mergeHeaders,
   parseURL: () => parseURL,
@@ -50,13 +51,16 @@ function filterCookies(cookies, urls) {
         continue;
       if (!parsedURL.pathname.startsWith(c.path))
         continue;
-      if (parsedURL.protocol !== "https:" && parsedURL.hostname !== "localhost" && c.secure)
+      if (parsedURL.protocol !== "https:" && !isLocalHostname(parsedURL.hostname) && c.secure)
         continue;
       return true;
     }
     return false;
   });
 }
+function isLocalHostname(hostname) {
+  return hostname === "localhost" || hostname.endsWith(".localhost");
+}
 const kMaxCookieExpiresDateInSeconds = 253402300799;
 function rewriteCookies(cookies) {
   return cookies.map((c) => {
@@ -121,16 +125,17 @@ class Request extends import_instrumentation.SdkObject {
     this._failureText = failureText;
     this._waitForResponsePromise.resolve(null);
   }
-  _setOverrides(overrides) {
-    this._overrides = overrides;
+  _applyOverrides(overrides) {
+    this._overrides = { ...this._overrides, ...overrides };
     this._updateHeadersMap();
+    return this._overrides;
   }
   _updateHeadersMap() {
     for (const { name, value } of this.headers())
       this._headersMap.set(name.toLowerCase(), value);
   }
-  _hasOverrides() {
-    return !!this._overrides;
+  overrides() {
+    return this._overrides;
   }
   url() {
     return this._overrides?.url || this._url;
@@ -212,10 +217,24 @@ class Route extends import_instrumentation.SdkObject {
   constructor(request, delegate) {
     super(request._frame || request._context, "route");
     this._handled = false;
+    this._futureHandlers = [];
     this._request = request;
     this._delegate = delegate;
     this._request._context.addRouteInFlight(this);
   }
+  handle(handlers) {
+    this._futureHandlers = [...handlers];
+    this.continue({ isFallback: true }).catch(() => {
+    });
+  }
+  async removeHandler(handler) {
+    this._futureHandlers = this._futureHandlers.filter((h) => h !== handler);
+    if (handler === this._currentHandler) {
+      await this.continue({ isFallback: true }).catch(() => {
+      });
+      return;
+    }
+  }
   request() {
     return this._request;
   }
@@ -225,10 +244,11 @@ class Route extends import_instrumentation.SdkObject {
     await this._delegate.abort(errorCode);
     this._endHandling();
   }
-  async redirectNavigationRequest(url) {
+  redirectNavigationRequest(url) {
     this._startHandling();
     (0, import_utils.assert)(this._request.isNavigationRequest());
     this._request.frame().redirectNavigation(url, this._request._documentId, this._request.headerValue("referer"));
+    this._endHandling();
   }
   async fulfill(overrides) {
     this._startHandling();
@@ -274,26 +294,39 @@ class Route extends import_instrumentation.SdkObject {
     headers.push({ name: "vary", value: "Origin" });
   }
   async continue(overrides) {
-    this._startHandling();
     if (overrides.url) {
       const newUrl = new URL(overrides.url);
       const oldUrl = new URL(this._request.url());
       if (oldUrl.protocol !== newUrl.protocol)
         throw new Error("New URL must have same protocol as overridden URL");
     }
-    if (overrides.headers)
-      overrides.headers = overrides.headers?.filter((header) => header.name.toLowerCase() !== "cookie");
-    this._request._setOverrides(overrides);
+    if (overrides.headers) {
+      overrides.headers = overrides.headers?.filter((header) => {
+        const headerName = header.name.toLowerCase();
+        return headerName !== "cookie" && headerName !== "host";
+      });
+    }
+    overrides = this._request._applyOverrides(overrides);
+    const nextHandler = this._futureHandlers.shift();
+    if (nextHandler) {
+      this._currentHandler = nextHandler;
+      nextHandler(this, this._request);
+      return;
+    }
     if (!overrides.isFallback)
       this._request._context.emit(import_browserContext.BrowserContext.Events.RequestContinued, this._request);
+    this._startHandling();
     await this._delegate.continue(overrides);
     this._endHandling();
   }
   _startHandling() {
     (0, import_utils.assert)(!this._handled, "Route is already handled!");
     this._handled = true;
+    this._currentHandler = void 0;
   }
   _endHandling() {
+    this._futureHandlers = [];
+    this._currentHandler = void 0;
     this._request._context.removeRouteInFlight(this);
   }
 }
@@ -573,6 +606,7 @@ function mergeHeaders(headers) {
   Route,
   WebSocket,
   filterCookies,
+  isLocalHostname,
   kMaxCookieExpiresDateInSeconds,
   mergeHeaders,
   parseURL,