patchright-core 1.56.1 → 1.58.2

package/lib/server/chromium/crPage.js

@@ -32,9 +32,7 @@ __export(crPage_exports, {
 });
 module.exports = __toCommonJS(crPage_exports);
 var import_crypto = __toESM(require("crypto"));
-var import_path = __toESM(require("path"));
 var import_assert = require("../../utils/isomorphic/assert");
-var import_crypto2 = require("../utils/crypto");
 var import_eventsHelper = require("../utils/eventsHelper");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
 var dialog = __toESM(require("../dialog"));
@@ -43,8 +41,6 @@ var frames = __toESM(require("../frames"));
 var import_helper = require("../helper");
 var network = __toESM(require("../network"));
 var import_page = require("../page");
-var import_registry = require("../registry");
-var import_crAccessibility = require("./crAccessibility");
 var import_crCoverage = require("./crCoverage");
 var import_crDragDrop = require("./crDragDrop");
 var import_crExecutionContext = require("./crExecutionContext");
@@ -53,7 +49,6 @@ var import_crNetworkManager = require("./crNetworkManager");
 var import_crPdf = require("./crPdf");
 var import_crProtocolHelper = require("./crProtocolHelper");
 var import_defaultFontFamilies = require("./defaultFontFamilies");
-var import_videoRecorder = require("./videoRecorder");
 var import_errors = require("../errors");
 var import_protocolError = require("../protocolError");
 class CRPage {
@@ -115,7 +110,7 @@ class CRPage {
     while (!this._sessions.has(frame._id)) {
       const parent = frame.parentFrame();
       if (!parent)
-        throw new Error(`Frame has been detached.`);
+        throw new Error(`Frame was detached`);
       frame = parent;
     }
     return this._sessions.get(frame._id);
@@ -240,17 +235,16 @@ class CRPage {
   async scrollRectIntoViewIfNeeded(handle, rect) {
     return this._sessionForHandle(handle)._scrollRectIntoViewIfNeeded(handle, rect);
   }
-  async setScreencastOptions(options) {
-    if (options) {
-      await this._mainFrameSession._startScreencast(this, {
-        format: "jpeg",
-        quality: options.quality,
-        maxWidth: options.width,
-        maxHeight: options.height
-      });
-    } else {
-      await this._mainFrameSession._stopScreencast(this);
-    }
+  async startScreencast(options) {
+    await this._mainFrameSession._client.send("Page.startScreencast", {
+      format: "jpeg",
+      quality: options.quality,
+      maxWidth: options.width,
+      maxHeight: options.height
+    });
+  }
+  async stopScreencast() {
+    await this._mainFrameSession._client._sendMayFail("Page.stopScreencast");
   }
   rafCountForStablePosition() {
     return 1;
@@ -271,9 +265,6 @@ class CRPage {
   async adoptElementHandle(handle, to) {
     return this._sessionForHandle(handle)._adoptElementHandle(handle, to);
   }
-  async getAccessibilityTree(needle) {
-    return (0, import_crAccessibility.getAccessibilityTree)(this._mainFrameSession._client, needle);
-  }
   async inputActionEpilogue() {
     await this._mainFrameSession._client.send("Page.enable").catch((e) => {
     });
@@ -326,9 +317,6 @@ class FrameSession {
     // Marks the oopif session that remote -> local transition has happened in the parent.
     // See Target.detachedFromTarget handler for details.
     this._swappedIn = false;
-    this._videoRecorder = null;
-    this._screencastId = null;
-    this._screencastClients = /* @__PURE__ */ new Set();
     this._workerSessions = /* @__PURE__ */ new Map();
     this._initScriptIds = /* @__PURE__ */ new Map();
     this._exposedBindingNames = [];
@@ -380,38 +368,32 @@ class FrameSession {
     ]);
   }
   async _initialize(hasUIWindow) {
+    const pageEnablePromise = this._client.send("Page.enable");
     if (!this._page.isStorageStatePage && hasUIWindow && !this._crPage._browserContext._browser.isClank() && !this._crPage._browserContext._options.noDefaultViewport) {
       const { windowId } = await this._client.send("Browser.getWindowForTarget");
       this._windowId = windowId;
     }
-    let screencastOptions;
-    if (!this._page.isStorageStatePage && this._isMainFrame() && this._crPage._browserContext._options.recordVideo && hasUIWindow) {
-      const screencastId = (0, import_crypto2.createGuid)();
-      const outputFile = import_path.default.join(this._crPage._browserContext._options.recordVideo.dir, screencastId + ".webm");
-      screencastOptions = {
-        // validateBrowserContextOptions ensures correct video size.
-        ...this._crPage._browserContext._options.recordVideo.size,
-        outputFile
-      };
-      await this._crPage._browserContext._ensureVideosPath();
-      await this._createVideoRecorder(screencastId, screencastOptions);
-      this._crPage._page.waitForInitializedOrError().then((p) => {
-        if (p instanceof Error)
-          this._stopVideoRecording().catch(() => {
-          });
-      });
-    }
+    let videoOptions;
+    if (!this._page.isStorageStatePage && this._isMainFrame() && hasUIWindow)
+      videoOptions = this._crPage._page.screencast.launchVideoRecorder();
     let lifecycleEventsEnabled;
     if (!this._isMainFrame())
       this._addRendererListeners();
+    let bufferedDialogEvents = this._isMainFrame() ? [] : void 0;
+    if (bufferedDialogEvents)
+      this._eventListeners.push(import_eventsHelper.eventsHelper.addEventListener(this._client, "Page.javascriptDialogOpening", (event) => bufferedDialogEvents ? bufferedDialogEvents.push(event) : void 0));
     this._addBrowserListeners();
     this._bufferedAttachedToTargetEvents = [];
     const promises = [
-      this._client.send("Page.enable"),
+      pageEnablePromise,
       this._client.send("Page.getFrameTree").then(({ frameTree }) => {
         if (this._isMainFrame()) {
           this._handleFrameTree(frameTree);
           this._addRendererListeners();
+          const pendingDialogEvents = bufferedDialogEvents || [];
+          bufferedDialogEvents = void 0;
+          for (const event of pendingDialogEvents)
+            this._onDialog(event);
         }
         const attachedToTargetEvents = this._bufferedAttachedToTargetEvents || [];
         this._bufferedAttachedToTargetEvents = void 0;
@@ -426,12 +408,16 @@ class FrameSession {
         } else {
           const localFrames = this._isMainFrame() ? this._page.frames() : [this._page.frameManager.frame(this._targetId)];
           for (const frame of localFrames) {
-            this._page.frameManager.frame(frame._id)._context("utility");
+            this._page.frameManager.frame(frame._id)._context("utility").catch(() => {
+            });
             for (const binding of this._crPage._browserContext._pageBindings.values())
               frame.evaluateExpression(binding.source).catch((e) => {
               });
             for (const source of this._crPage._browserContext.initScripts)
-              frame.evaluateExpression(source).catch((e) => {
+              frame.evaluateExpression(source.source).catch((e) => {
+              });
+            for (const source of this._crPage._page.initScripts)
+              frame.evaluateExpression(source.source).catch((e) => {
               });
           }
           this._firstNonInitialNavigationCommittedFulfill();
@@ -450,7 +436,7 @@ class FrameSession {
     if (!this._page.isStorageStatePage) {
       if (this._crPage._browserContext.needsPlaywrightBinding())
         promises.push(this.exposePlaywrightBinding());
-      if (this._isMainFrame())
+      if (this._isMainFrame() && !this._crPage._browserContext._options.focusControl)
         promises.push(this._client.send("Emulation.setFocusEmulationEnabled", { enabled: true }));
       const options = this._crPage._browserContext._options;
       if (options.bypassCSP)
@@ -477,18 +463,15 @@ class FrameSession {
       for (const binding of this._crPage._page.allBindings()) promises.push(this._initBinding(binding));
       for (const initScript of this._crPage._browserContext.initScripts) promises.push(this._evaluateOnNewDocument(initScript, "main"));
       for (const initScript of this._crPage._page.initScripts) promises.push(this._evaluateOnNewDocument(initScript, "main"));
-      if (screencastOptions)
-        promises.push(this._startVideoRecording(screencastOptions));
+      if (videoOptions)
+        promises.push(this._crPage._page.screencast.startVideoRecording(videoOptions));
     }
-    if (!(this._crPage._page._pageBindings.size || this._crPage._browserContext._pageBindings.size))
-      promises.push(this._client.send("Runtime.runIfWaitingForDebugger"));
+    promises.push(this._client.send("Runtime.runIfWaitingForDebugger"));
     promises.push(this._firstNonInitialNavigationCommittedPromise);
     await Promise.all(promises);
-    if (this._crPage._page._pageBindings.size || this._crPage._browserContext._pageBindings.size)
-      await this._client.send("Runtime.runIfWaitingForDebugger");
   }
   dispose() {
-    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError());
+    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError(this._page.closeReason()));
     for (const childSession of this._childSessions)
       childSession.dispose();
     if (this._parentSession)
@@ -513,6 +496,10 @@ class FrameSession {
       this._page.frameManager.frameLifecycleEvent(event.frameId, "load");
     else if (event.name === "DOMContentLoaded")
       this._page.frameManager.frameLifecycleEvent(event.frameId, "domcontentloaded");
+    if (event.name !== "load") {
+      await this._client._sendMayFail("Runtime.runIfWaitingForDebugger");
+      return;
+    }
     await this._client._sendMayFail("Runtime.runIfWaitingForDebugger");
     var document = await this._client._sendMayFail("DOM.getDocument");
     if (!document) return;
@@ -565,6 +552,14 @@ class FrameSession {
     if (!initial)
       this._firstNonInitialNavigationCommittedFulfill();
     await this._client._sendMayFail("Runtime.runIfWaitingForDebugger");
+    if (!initial) {
+      try {
+        await this._page.frameManager.frame(this._targetId)._context("utility");
+      } catch {
+      }
+      ;
+      return;
+    }
     var document = await this._client._sendMayFail("DOM.getDocument");
     if (!document) return;
     var query = await this._client._sendMayFail("DOM.querySelectorAll", {
@@ -613,7 +608,7 @@ class FrameSession {
     const delegate = new import_crExecutionContext.CRExecutionContext(this._client, contextPayload);
     let worldName = contextPayload.name;
     const context = new dom.FrameExecutionContext(delegate, frame, worldName);
-    if (worldName)
+    if (worldName && (worldName === "main" || worldName === "utility"))
       frame._contextCreated(worldName, context);
     this._contextIdToContext.set(contextPayload.id, context);
     for (const source of this._exposedBindingScripts) {
@@ -680,6 +675,10 @@ class FrameSession {
       var executionContextId = parseInt(globalThisObjId.split(".")[1], 10);
       worker.createExecutionContext(new import_crExecutionContext.CRExecutionContext(session, { id: executionContextId }));
     }
+    if (this._crPage._browserContext._browser.majorVersion() >= 143)
+      session.on("Inspector.workerScriptLoaded", () => worker.workerScriptLoaded());
+    else
+      worker.workerScriptLoaded();
     this._crPage._networkManager.addSession(session, this._page.frameManager.frame(this._targetId) ?? void 0).catch(() => {
     });
     session._sendMayFail("Runtime.runIfWaitingForDebugger");
@@ -688,7 +687,7 @@ class FrameSession {
     session.on("Target.detachedFromTarget", (event2) => this._onDetachedFromTarget(event2));
     session.on("Runtime.consoleAPICalled", (event2) => {
       const args = event2.args.map((o) => (0, import_crExecutionContext.createHandle)(worker.existingExecutionContext, o));
-      this._page.addConsoleMessage(event2.type, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event2.stackTrace));
+      this._page.addConsoleMessage(worker, event2.type, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event2.stackTrace));
     });
     session.on("Runtime.exceptionThrown", (exception) => this._page.addPageError((0, import_crProtocolHelper.exceptionToError)(exception.exceptionDetails)));
   }
@@ -723,7 +722,7 @@ class FrameSession {
     if (!context)
       return;
     const values = event.args.map((arg) => (0, import_crExecutionContext.createHandle)(context, arg));
-    this._page.addConsoleMessage(event.type, values, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
+    this._page.addConsoleMessage(null, event.type, values, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
   }
   async _onBindingCalled(event) {
     const pageOrError = await this._crPage._page.waitForInitializedOrError();
@@ -765,7 +764,7 @@ class FrameSession {
         lineNumber: lineNumber || 0,
         columnNumber: 0
       };
-      this._page.addConsoleMessage(level, [], location, text);
+      this._page.addConsoleMessage(null, level, [], location, text);
     }
   }
   async _onFileChooserOpened(event) {
@@ -789,63 +788,17 @@ class FrameSession {
     }
   }
   _onScreencastFrame(payload) {
-    this._page.throttleScreencastFrameAck(() => {
-      this._client.send("Page.screencastFrameAck", { sessionId: payload.sessionId }).catch(() => {
-      });
+    this._page.screencast.throttleFrameAck(() => {
+      this._client._sendMayFail("Page.screencastFrameAck", { sessionId: payload.sessionId });
     });
     const buffer = Buffer.from(payload.data, "base64");
     this._page.emit(import_page.Page.Events.ScreencastFrame, {
       buffer,
-      frameSwapWallTime: payload.metadata.timestamp ? payload.metadata.timestamp * 1e3 : void 0,
+      frameSwapWallTime: payload.metadata.timestamp ? payload.metadata.timestamp * 1e3 : Date.now(),
       width: payload.metadata.deviceWidth,
       height: payload.metadata.deviceHeight
     });
   }
-  async _createVideoRecorder(screencastId, options) {
-    (0, import_assert.assert)(!this._screencastId);
-    const ffmpegPath = import_registry.registry.findExecutable("ffmpeg").executablePathOrDie(this._page.browserContext._browser.sdkLanguage());
-    this._videoRecorder = await import_videoRecorder.VideoRecorder.launch(this._crPage._page, ffmpegPath, options);
-    this._screencastId = screencastId;
-  }
-  async _startVideoRecording(options) {
-    const screencastId = this._screencastId;
-    (0, import_assert.assert)(screencastId);
-    this._page.once(import_page.Page.Events.Close, () => this._stopVideoRecording().catch(() => {
-    }));
-    const gotFirstFrame = new Promise((f) => this._client.once("Page.screencastFrame", f));
-    await this._startScreencast(this._videoRecorder, {
-      format: "jpeg",
-      quality: 90,
-      maxWidth: options.width,
-      maxHeight: options.height
-    });
-    gotFirstFrame.then(() => {
-      this._crPage._browserContext._browser._videoStarted(this._crPage._browserContext, screencastId, options.outputFile, this._crPage._page.waitForInitializedOrError());
-    });
-  }
-  async _stopVideoRecording() {
-    if (!this._screencastId)
-      return;
-    const screencastId = this._screencastId;
-    this._screencastId = null;
-    const recorder = this._videoRecorder;
-    this._videoRecorder = null;
-    await this._stopScreencast(recorder);
-    await recorder.stop().catch(() => {
-    });
-    const video = this._crPage._browserContext._browser._takeVideo(screencastId);
-    video?.reportFinished();
-  }
-  async _startScreencast(client, options = {}) {
-    this._screencastClients.add(client);
-    if (this._screencastClients.size === 1)
-      await this._client.send("Page.startScreencast", options);
-  }
-  async _stopScreencast(client) {
-    this._screencastClients.delete(client);
-    if (!this._screencastClients.size)
-      await this._client._sendMayFail("Page.stopScreencast");
-  }
   async _updateGeolocation(initial) {
     const geolocation = this._crPage._browserContext._options.geolocation;
     if (!initial || geolocation)
@@ -1049,29 +1002,20 @@ class FrameSession {
     return (0, import_crExecutionContext.createHandle)(to, result.object).asElement();
   }
   async _initBinding(binding = import_page.PageBinding) {
-    var result = await this._client._sendMayFail("Page.createIsolatedWorld", {
-      frameId: this._targetId,
-      grantUniveralAccess: true,
-      worldName: "utility"
-    });
-    if (!result) return;
-    var isolatedContextId = result.executionContextId;
-    var globalThis = await this._client._sendMayFail("Runtime.evaluate", {
-      expression: "globalThis",
-      serializationOptions: { serialization: "idOnly" }
-    });
-    if (!globalThis) return;
-    var globalThisObjId = globalThis["result"]["objectId"];
-    var mainContextId = parseInt(globalThisObjId.split(".")[1], 10);
+    this._exposedBindingNames.push(binding.name);
+    this._exposedBindingScripts.push(binding.source);
+    const contextIds = Array.from(this._contextIdToContext.keys());
     await Promise.all([
       this._client._sendMayFail("Runtime.addBinding", { name: binding.name }),
-      this._client._sendMayFail("Runtime.addBinding", { name: binding.name, executionContextId: mainContextId }),
-      this._client._sendMayFail("Runtime.addBinding", { name: binding.name, executionContextId: isolatedContextId })
-      // this._client._sendMayFail("Runtime.evaluate", { expression: binding.source, contextId: mainContextId, awaitPromise: true })
+      ...contextIds.map((executionContextId) => this._client._sendMayFail("Runtime.addBinding", { name: binding.name, executionContextId }))
     ]);
-    this._exposedBindingNames.push(binding.name);
-    this._exposedBindingScripts.push(binding.source);
-    await this._crPage.addInitScript(binding.source);
+    for (const contextId of contextIds) {
+      this._client._sendMayFail("Runtime.evaluate", {
+        expression: binding.source,
+        contextId,
+        awaitPromise: true
+      });
+    }
   }
   async _removeExposedBindings() {
     const toRetain = [];

package/lib/server/chromium/crServiceWorker.js

@@ -36,16 +36,22 @@ var import_crExecutionContext = require("./crExecutionContext");
 var import_crNetworkManager = require("./crNetworkManager");
 var import_browserContext = require("../browserContext");
 var network = __toESM(require("../network"));
+var import_console = require("../console");
+var import_crProtocolHelper = require("./crProtocolHelper");
 class CRServiceWorker extends import_page.Worker {
   constructor(browserContext, session, url) {
     super(browserContext, url);
     this._session = session;
     this.browserContext = browserContext;
-    if (!!process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS)
+    if (!process.env.PLAYWRIGHT_DISABLE_SERVICE_WORKER_NETWORK)
       this._networkManager = new import_crNetworkManager.CRNetworkManager(null, this);
     session.once("Runtime.executionContextCreated", (event) => {
       this.createExecutionContext(new import_crExecutionContext.CRExecutionContext(session, event.context));
     });
+    if (this.browserContext._browser.majorVersion() >= 143)
+      session.on("Inspector.workerScriptLoaded", () => this.workerScriptLoaded());
+    else
+      this.workerScriptLoaded();
     if (this._networkManager && this._isNetworkInspectionEnabled()) {
       this.updateRequestInterception();
       this.updateExtraHTTPHeaders();
@@ -59,6 +65,13 @@ class CRServiceWorker extends import_page.Worker {
       ).catch(() => {
       });
     }
+    session.on("Runtime.consoleAPICalled", (event) => {
+      if (!this.existingExecutionContext || process.env.PLAYWRIGHT_DISABLE_SERVICE_WORKER_CONSOLE)
+        return;
+      const args = event.args.map((o) => (0, import_crExecutionContext.createHandle)(this.existingExecutionContext, o));
+      const message = new import_console.ConsoleMessage(null, this, event.type, void 0, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
+      this.browserContext.emit(import_browserContext.BrowserContext.Events.Console, message);
+    });
     session.send("Runtime.runIfWaitingForDebugger").catch((e) => {
     });
     session.on("Inspector.targetReloadedAfterCrash", () => {

package/lib/server/codegen/javascript.js

@@ -90,7 +90,7 @@ class JavaScriptLanguageGenerator {
       case "fill":
         return `await ${subject}.${this._asLocator(action.selector)}.fill(${quote(action.text)});`;
       case "setInputFiles":
-        return `await ${subject}.${this._asLocator(action.selector)}.setInputFiles(${formatObject(action.files.length === 1 ? action.files[0] : action.files)});`;
+        return `await ${subject}.${this._asLocator(action.selector)}.setInputFiles(${(0, import_utils.formatObject)(action.files.length === 1 ? action.files[0] : action.files)});`;
       case "press": {
         const modifiers = (0, import_language.toKeyboardModifiers)(action.modifiers);
         const shortcut = [...modifiers, action.key].join("+");
@@ -99,7 +99,7 @@ class JavaScriptLanguageGenerator {
       case "navigate":
         return `await ${subject}.goto(${quote(action.url)});`;
       case "select":
-        return `await ${subject}.${this._asLocator(action.selector)}.selectOption(${formatObject(action.options.length === 1 ? action.options[0] : action.options)});`;
+        return `await ${subject}.${this._asLocator(action.selector)}.selectOption(${(0, import_utils.formatObject)(action.options.length === 1 ? action.options[0] : action.options)});`;
       case "assertText":
         return `${this._isTest ? "" : "// "}await expect(${subject}.${this._asLocator(action.selector)}).${action.substring ? "toContainText" : "toHaveText"}(${quote(action.text)});`;
       case "assertChecked":
@@ -151,7 +151,7 @@ ${useText ? "\ntest.use(" + useText + ");\n" : ""}
       const { ${options.browserName}${options.deviceName ? ", devices" : ""} } = require('playwright');
 
       (async () => {
-        const browser = await ${options.browserName}.launch(${formatObjectOrVoid(options.launchOptions)});
+        const browser = await ${options.browserName}.launch(${(0, import_utils.formatObjectOrVoid)(options.launchOptions)});
         const context = await browser.newContext(${formatContextOptions(options.contextOptions, options.deviceName, false)});`);
     if (options.contextOptions.recordHar)
       formatter.add(`        await context.routeFromHAR(${quote(options.contextOptions.recordHar.path)});`);
@@ -171,37 +171,14 @@ function formatOptions(value, hasArguments) {
   const keys = Object.keys(value).filter((key) => value[key] !== void 0);
   if (!keys.length)
     return "";
-  return (hasArguments ? ", " : "") + formatObject(value);
-}
-function formatObject(value, indent = "  ") {
-  if (typeof value === "string")
-    return quote(value);
-  if (Array.isArray(value))
-    return `[${value.map((o) => formatObject(o)).join(", ")}]`;
-  if (typeof value === "object") {
-    const keys = Object.keys(value).filter((key) => value[key] !== void 0).sort();
-    if (!keys.length)
-      return "{}";
-    const tokens = [];
-    for (const key of keys)
-      tokens.push(`${key}: ${formatObject(value[key])}`);
-    return `{
-${indent}${tokens.join(`,
-${indent}`)}
-}`;
-  }
-  return String(value);
-}
-function formatObjectOrVoid(value, indent = "  ") {
-  const result = formatObject(value, indent);
-  return result === "{}" ? "" : result;
+  return (hasArguments ? ", " : "") + (0, import_utils.formatObject)(value);
 }
 function formatContextOptions(options, deviceName, isTest) {
   const device = deviceName && import_deviceDescriptors.deviceDescriptors[deviceName];
   options = { ...options, recordHar: void 0 };
   if (!device)
-    return formatObjectOrVoid(options);
-  let serializedObject = formatObjectOrVoid((0, import_language.sanitizeDeviceOptions)(device, options));
+    return (0, import_utils.formatObjectOrVoid)(options);
+  let serializedObject = (0, import_utils.formatObjectOrVoid)((0, import_language.sanitizeDeviceOptions)(device, options));
   if (!serializedObject)
     serializedObject = "{\n}";
   const lines = serializedObject.split("\n");

package/lib/server/console.js

@@ -22,8 +22,9 @@ __export(console_exports, {
 });
 module.exports = __toCommonJS(console_exports);
 class ConsoleMessage {
-  constructor(page, type, text, args, location) {
+  constructor(page, worker, type, text, args, location) {
     this._page = page;
+    this._worker = worker;
     this._type = type;
     this._text = text;
     this._args = args;
@@ -32,6 +33,9 @@ class ConsoleMessage {
   page() {
     return this._page;
   }
+  worker() {
+    return this._worker;
+  }
   type() {
     return this._type;
   }