patchright-core 1.58.2 → 1.59.1

package/lib/server/firefox/ffInput.js

@@ -23,6 +23,20 @@ __export(ffInput_exports, {
   RawTouchscreenImpl: () => RawTouchscreenImpl
 });
 module.exports = __toCommonJS(ffInput_exports);
+const kFirefoxKeyOverrides = /* @__PURE__ */ new Map([
+  ["AudioVolumeMute", { code: "VolumeMute", keyCodeWithoutLocation: 181 }],
+  ["AudioVolumeDown", { code: "VolumeDown", keyCodeWithoutLocation: 182 }],
+  ["AudioVolumeUp", { code: "VolumeUp", keyCodeWithoutLocation: 183 }]
+]);
+function toFirefoxKeyDescription(description) {
+  const override = kFirefoxKeyOverrides.get(description.key);
+  if (!override)
+    return description;
+  return {
+    ...description,
+    ...override
+  };
+}
 function toModifiersMask(modifiers) {
   let mask = 0;
   if (modifiers.has("Alt"))
@@ -59,13 +73,14 @@ class RawKeyboardImpl {
     this._client = client;
   }
   async keydown(progress, modifiers, keyName, description, autoRepeat) {
-    let text = description.text;
+    const keyDescription = toFirefoxKeyDescription(description);
+    let text = keyDescription.text;
     if (text === "\r")
       text = "";
-    const { code, key, location } = description;
+    const { code, key, location } = keyDescription;
     await progress.race(this._client.send("Page.dispatchKeyEvent", {
       type: "keydown",
-      keyCode: description.keyCodeWithoutLocation,
+      keyCode: keyDescription.keyCodeWithoutLocation,
       code,
       key,
       repeat: autoRepeat,
@@ -74,11 +89,12 @@ class RawKeyboardImpl {
     }));
   }
   async keyup(progress, modifiers, keyName, description) {
-    const { code, key, location } = description;
+    const keyDescription = toFirefoxKeyDescription(description);
+    const { code, key, location } = keyDescription;
     await progress.race(this._client.send("Page.dispatchKeyEvent", {
       type: "keyup",
       key,
-      keyCode: description.keyCodeWithoutLocation,
+      keyCode: keyDescription.keyCodeWithoutLocation,
       code,
       location,
       repeat: false

package/lib/server/firefox/ffNetworkManager.js

@@ -133,8 +133,7 @@ class FFNetworkManager {
       this._requests.delete(request._id);
       response._requestFinished(responseEndTime);
     }
-    if (event.protocolVersion)
-      response._setHttpVersion(event.protocolVersion);
+    response._setHttpVersion(event.protocolVersion ?? null);
     this._page.frameManager.reportRequestFinished(request.request, response);
   }
   _onRequestFailed(event) {
@@ -147,6 +146,7 @@ class FFNetworkManager {
       response.setTransferSize(null);
       response.setEncodedBodySize(null);
       response._requestFinished(-1);
+      response._setHttpVersion(null);
     }
     request.request._setFailureText(event.errorCode);
     this._page.frameManager.requestFailed(request.request, event.errorCode === "NS_BINDING_ABORTED");

package/lib/server/firefox/ffPage.js

@@ -43,7 +43,7 @@ var import_ffInput = require("./ffInput");
 var import_ffNetworkManager = require("./ffNetworkManager");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
 var import_errors = require("../errors");
-var import_debugLogger = require("../utils/debugLogger");
+var import_videoRecorder = require("../videoRecorder");
 const UTILITY_WORLD_NAME = "__playwright_utility_world__";
 class FFPage {
   constructor(session, browserContext, opener) {
@@ -89,19 +89,14 @@ class FFPage {
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.webSocketFrameSent", this._onWebSocketFrameSent.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.screencastFrame", this._onScreencastFrame.bind(this))
     ];
-    const screencast = this._page.screencast;
-    const videoOptions = screencast.launchVideoRecorder();
-    if (videoOptions)
-      screencast.startVideoRecording(videoOptions).catch((e) => import_debugLogger.debugLogger.log("error", e));
-    this._session.once("Page.ready", () => {
-      if (this._reportedAsNew)
-        return;
-      this._reportedAsNew = true;
-      this._page.reportAsNew(this._opener?._page);
-    });
-    this.addInitScript(new import_page.InitScript(""), UTILITY_WORLD_NAME).catch((e) => this._markAsError(e));
-  }
-  async _markAsError(error) {
+    const promises = [];
+    if (!this._page.isStorageStatePage)
+      (0, import_videoRecorder.startAutomaticVideoRecording)(this._page);
+    promises.push(new Promise((f) => this._session.once("Page.ready", f)));
+    Promise.all(promises).then(() => this._reportAsNew(), (error) => this._reportAsNew(error));
+    this.addInitScript(new import_page.InitScript(this._page, ""), UTILITY_WORLD_NAME).catch((e) => this._reportAsNew(e));
+  }
+  _reportAsNew(error) {
     if (this._reportedAsNew)
       return;
     this._reportedAsNew = true;
@@ -203,7 +198,8 @@ class FFPage {
     const context = this._contextIdToContext.get(executionContextId);
     if (!context)
       return;
-    this._page.addConsoleMessage(null, type === "warn" ? "warning" : type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location);
+    const timestamp = Date.now();
+    this._page.addConsoleMessage(null, type === "warn" ? "warning" : type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location, void 0, timestamp);
   }
   _onDialogOpened(params) {
     this._page.browserContext.dialogManager.dialogDidOpen(new dialog.Dialog(
@@ -253,7 +249,7 @@ class FFPage {
     workerSession.on("Runtime.console", (event2) => {
       const { type, args, location } = event2;
       const context = worker.existingExecutionContext;
-      this._page.addConsoleMessage(worker, type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location);
+      this._page.addConsoleMessage(worker, type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location, void 0, Date.now());
     });
   }
   _onWorkerDestroyed(event) {
@@ -276,7 +272,7 @@ class FFPage {
     this._page._didCrash();
   }
   didClose() {
-    this._markAsError(new import_errors.TargetClosedError(this._page.closeReason()));
+    this._reportAsNew(new import_errors.TargetClosedError(this._page.closeReason()));
     this._session.dispose();
     import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
     this._networkManager.dispose();
@@ -417,23 +413,22 @@ class FFPage {
       throw e;
     });
   }
-  async startScreencast(options) {
-    await this._session.send("Page.startScreencast", options);
+  startScreencast(options) {
+    this._session.sendMayFail("Page.startScreencast", { width: options.width, height: options.height, quality: options.quality });
   }
-  async stopScreencast() {
-    await this._session.sendMayFail("Page.stopScreencast");
+  stopScreencast() {
+    this._session.sendMayFail("Page.stopScreencast");
   }
   _onScreencastFrame(event) {
-    this._page.screencast.throttleFrameAck(() => {
-      this._session.sendMayFail("Page.screencastFrameAck");
-    });
     const buffer = Buffer.from(event.data, "base64");
-    this._page.emit(import_page2.Page.Events.ScreencastFrame, {
+    this._page.screencast.onScreencastFrame({
       buffer,
       frameSwapWallTime: event.timestamp * 1e3,
       // timestamp is in seconds, we need to convert to milliseconds.
-      width: event.deviceWidth,
-      height: event.deviceHeight
+      viewportWidth: event.deviceWidth,
+      viewportHeight: event.deviceHeight
+    }, () => {
+      this._session.sendMayFail("Page.screencastFrameAck");
     });
   }
   rafCountForStablePosition() {
@@ -486,6 +481,8 @@ class FFPage {
   shouldToggleStyleSheetToSyncAnimations() {
     return false;
   }
+  async setDockTile(image) {
+  }
 }
 function webSocketId(frameId, wsid) {
   return `${frameId}---${wsid}`;

package/lib/server/frameSelectors.js

@@ -21,7 +21,6 @@ __export(frameSelectors_exports, {
   FrameSelectors: () => FrameSelectors
 });
 module.exports = __toCommonJS(frameSelectors_exports);
-var import_dom = require("./dom");
 var import_utils = require("../utils");
 var import_selectorParser = require("../utils/isomorphic/selectorParser");
 class FrameSelectors {
@@ -46,8 +45,8 @@ class FrameSelectors {
     }
     return adoptIfNeeded(elementHandle, await resolved.frame._mainContext());
   }
-  async queryArrayInMainWorld(selector, scope, isolatedContext) {
-    const resolved = await this.resolveInjectedForSelector(selector, { mainWorld: !isolatedContext }, scope);
+  async queryArrayInMainWorld(selector, scope) {
+    const resolved = await this.resolveInjectedForSelector(selector, { mainWorld: true }, scope);
     if (!resolved)
       throw new Error(`Failed to find frame for selector "${selector}"`);
     return await resolved.injected.evaluateHandle((injected, { info, scope: scope2 }) => {
@@ -124,29 +123,9 @@ class FrameSelectors {
           throw injected.createStacklessError(`Selector "${selectorString}" resolved to ${injected.previewNode(element2)}, <iframe> was expected`);
         return element2;
       }, { info, scope: i === 0 ? scope : void 0, selectorString: (0, import_selectorParser.stringifySelector)(info.parsed) });
-      let element = handle.asElement();
-      if (!element) {
-        try {
-          var client = frame._page.delegate._sessionForFrame(frame)._client;
-        } catch (e) {
-          var client = frame._page.delegate._mainFrameSession._client;
-        }
-        var mainContext = await frame._context("main");
-        const documentNode = await client.send("Runtime.evaluate", {
-          expression: "document",
-          serializationOptions: {
-            serialization: "idOnly"
-          },
-          contextId: mainContext.delegate._contextId
-        });
-        const documentScope = new import_dom.ElementHandle(mainContext, documentNode.result.objectId);
-        var check = await this._customFindFramesByParsed(injectedScript, client, mainContext, documentScope, info.parsed);
-        if (check.length > 0) {
-          element = check[0];
-        } else {
-          return null;
-        }
-      }
+      const element = handle.asElement();
+      if (!element)
+        return null;
       const maybeFrame = await frame._page.delegate.getContentFrame(element);
       element.dispose();
       if (!maybeFrame)
@@ -164,155 +143,9 @@ class FrameSelectors {
     if (!resolved)
       return;
     const context = await resolved.frame._context(options?.mainWorld ? "main" : resolved.info.world);
-    if (!context) throw new Error("Frame was detached");
     const injected = await context.injectedScript();
     return { injected, info: resolved.info, frame: resolved.frame, scope: resolved.scope };
   }
-  async _customFindFramesByParsed(injected, client, context, documentScope, parsed) {
-    var parsedEdits = { ...parsed };
-    var currentScopingElements = [documentScope];
-    while (parsed.parts.length > 0) {
-      var part = parsed.parts.shift();
-      parsedEdits.parts = [part];
-      var elements = [];
-      var elementsIndexes = [];
-      if (part.name == "nth") {
-        const partNth = Number(part.body);
-        if (partNth > currentScopingElements.length || partNth < -currentScopingElements.length) {
-          return continuePolling;
-        } else {
-          currentScopingElements = [currentScopingElements.at(partNth)];
-          continue;
-        }
-      } else if (part.name == "internal:or") {
-        var orredElements = await this._customFindFramesByParsed(injected, client, context, documentScope, part.body.parsed);
-        elements = currentScopingElements.concat(orredElements);
-      } else if (part.name == "internal:and") {
-        var andedElements = await this._customFindFramesByParsed(injected, client, context, documentScope, part.body.parsed);
-        const backendNodeIds = new Set(andedElements.map((item) => item.backendNodeId));
-        elements = currentScopingElements.filter((item) => backendNodeIds.has(item.backendNodeId));
-      } else {
-        for (const scope of currentScopingElements) {
-          const describedScope = await client.send("DOM.describeNode", {
-            objectId: scope._objectId,
-            depth: -1,
-            pierce: true
-          });
-          var queryingElements = [];
-          let findClosedShadowRoots2 = function(node, results = []) {
-            if (!node || typeof node !== "object") return results;
-            if (node.shadowRoots && Array.isArray(node.shadowRoots)) {
-              for (const shadowRoot2 of node.shadowRoots) {
-                if (shadowRoot2.shadowRootType === "closed" && shadowRoot2.backendNodeId) {
-                  results.push(shadowRoot2.backendNodeId);
-                }
-                findClosedShadowRoots2(shadowRoot2, results);
-              }
-            }
-            if (node.nodeName !== "IFRAME" && node.children && Array.isArray(node.children)) {
-              for (const child of node.children) {
-                findClosedShadowRoots2(child, results);
-              }
-            }
-            return results;
-          };
-          var findClosedShadowRoots = findClosedShadowRoots2;
-          var shadowRootBackendIds = findClosedShadowRoots2(describedScope.node);
-          var shadowRoots = [];
-          for (var shadowRootBackendId of shadowRootBackendIds) {
-            var resolvedShadowRoot = await client.send("DOM.resolveNode", {
-              backendNodeId: shadowRootBackendId,
-              contextId: context.delegate._contextId
-            });
-            shadowRoots.push(new import_dom.ElementHandle(context, resolvedShadowRoot.object.objectId));
-          }
-          for (var shadowRoot of shadowRoots) {
-            const shadowElements = await shadowRoot.evaluateHandleInUtility(([injected2, node, { parsed: parsed2 }]) => {
-              const elements2 = injected2.querySelectorAll(parsed2, node);
-              return elements2;
-            }, {
-              parsed: parsedEdits
-            });
-            const shadowElementsAmount = await shadowElements.getProperty("length");
-            queryingElements.push([shadowElements, shadowElementsAmount, shadowRoot]);
-          }
-          const rootElements = await scope.evaluateHandleInUtility(([injected2, node, { parsed: parsed2 }]) => {
-            const elements2 = injected2.querySelectorAll(parsed2, node);
-            return elements2;
-          }, {
-            parsed: parsedEdits
-          });
-          const rootElementsAmount = await rootElements.getProperty("length");
-          queryingElements.push([rootElements, rootElementsAmount, injected]);
-          for (var queryedElement of queryingElements) {
-            var elementsToCheck = queryedElement[0];
-            var elementsAmount = await queryedElement[1].jsonValue();
-            var parentNode = queryedElement[2];
-            for (var i = 0; i < elementsAmount; i++) {
-              if (parentNode.constructor.name == "ElementHandle") {
-                var elementToCheck = await parentNode.evaluateHandleInUtility(([injected2, node, { index, elementsToCheck: elementsToCheck2 }]) => {
-                  return elementsToCheck2[index];
-                }, { index: i, elementsToCheck });
-              } else {
-                var elementToCheck = await parentNode.evaluateHandle((injected2, { index, elementsToCheck: elementsToCheck2 }) => {
-                  return elementsToCheck2[index];
-                }, { index: i, elementsToCheck });
-              }
-              elementToCheck.parentNode = parentNode;
-              var resolvedElement = await client.send("DOM.describeNode", {
-                objectId: elementToCheck._objectId,
-                depth: -1
-              });
-              elementToCheck.backendNodeId = resolvedElement.node.backendNodeId;
-              elementToCheck.nodePosition = this._findElementPositionInDomTree(elementToCheck, describedScope.node, context, "");
-              elements.push(elementToCheck);
-            }
-          }
-        }
-      }
-      const getParts = (pos) => (pos?.match(/../g) || []).map(Number);
-      elements.sort((a, b) => {
-        const partA = getParts(a.nodePosition);
-        const partB = getParts(b.nodePosition);
-        const maxLength = Math.max(partA.length, partB.length);
-        for (let i2 = 0; i2 < maxLength; i2++) {
-          const aVal = partA[i2] ?? -1;
-          const bVal = partB[i2] ?? -1;
-          if (aVal !== bVal) return aVal - bVal;
-        }
-        return 0;
-      });
-      currentScopingElements = Array.from(
-        new Map(elements.map((e) => [e.nodePosition, e])).values()
-      );
-    }
-    return currentScopingElements;
-  }
-  _findElementPositionInDomTree(element, queryingElement, documentScope, currentIndex) {
-    if (element.backendNodeId === queryingElement.backendNodeId) {
-      return currentIndex;
-    }
-    for (const child of queryingElement.children || []) {
-      const childrenNodeIndex = queryingElement.children.indexOf(child);
-      const childIndex = this._findElementPositionInDomTree(element, child, documentScope, currentIndex + "." + childrenNodeIndex.toString());
-      if (childIndex !== null) return childIndex;
-    }
-    if (queryingElement.shadowRoots && Array.isArray(queryingElement.shadowRoots)) {
-      for (const shadowRoot of queryingElement.shadowRoots) {
-        if (shadowRoot.shadowRootType === "closed" && shadowRoot.backendNodeId) {
-          const shadowRootHandle = new import_dom.ElementHandle(documentScope, shadowRoot.backendNodeId);
-          const childIndex = this._findElementPositionInDomTree(element, shadowRootHandle, documentScope, currentIndex);
-          if (childIndex !== null) return childIndex;
-        }
-        for (const shadowChild of shadowRoot.children || []) {
-          const shadowChildIndex = (shadowRoot.children || []).indexOf(shadowChild);
-          const childIndex = this._findElementPositionInDomTree(element, shadowChild, documentScope, currentIndex + "." + shadowChildIndex.toString());
-          if (childIndex !== null) return childIndex;
-        }
-      }
-    }
-    return null;
-  }
 }
 async function adoptIfNeeded(handle, context) {
   if (handle._context === context)