patchright-core 1.52.5 → 1.55.1

package/lib/server/dialog.js

@@ -18,7 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var dialog_exports = {};
 __export(dialog_exports, {
-  Dialog: () => Dialog
+  Dialog: () => Dialog,
+  DialogManager: () => DialogManager
 });
 module.exports = __toCommonJS(dialog_exports);
 var import_utils = require("../utils");
@@ -32,8 +33,6 @@ class Dialog extends import_instrumentation.SdkObject {
     this._message = message;
     this._onHandle = onHandle;
     this._defaultValue = defaultValue || "";
-    this._page._frameManager.dialogDidOpen(this);
-    this.instrumentation.onDialog(this);
   }
   page() {
     return this._page;
@@ -50,13 +49,13 @@ class Dialog extends import_instrumentation.SdkObject {
   async accept(promptText) {
     (0, import_utils.assert)(!this._handled, "Cannot accept dialog which is already handled!");
     this._handled = true;
-    this._page._frameManager.dialogWillClose(this);
+    this._page.browserContext.dialogManager.dialogWillClose(this);
     await this._onHandle(true, promptText);
   }
   async dismiss() {
     (0, import_utils.assert)(!this._handled, "Cannot dismiss dialog which is already handled!");
     this._handled = true;
-    this._page._frameManager.dialogWillClose(this);
+    this._page.browserContext.dialogManager.dialogWillClose(this);
     await this._onHandle(false);
   }
   async close() {
@@ -66,7 +65,52 @@ class Dialog extends import_instrumentation.SdkObject {
       await this.dismiss();
   }
 }
+class DialogManager {
+  constructor(instrumentation) {
+    this._dialogHandlers = /* @__PURE__ */ new Set();
+    this._openedDialogs = /* @__PURE__ */ new Set();
+    this._instrumentation = instrumentation;
+  }
+  dialogDidOpen(dialog) {
+    for (const frame of dialog.page().frameManager.frames())
+      frame._invalidateNonStallingEvaluations("JavaScript dialog interrupted evaluation");
+    this._openedDialogs.add(dialog);
+    this._instrumentation.onDialog(dialog);
+    let hasHandlers = false;
+    for (const handler of this._dialogHandlers) {
+      if (handler(dialog))
+        hasHandlers = true;
+    }
+    if (!hasHandlers)
+      dialog.close().then(() => {
+      });
+  }
+  dialogWillClose(dialog) {
+    this._openedDialogs.delete(dialog);
+  }
+  addDialogHandler(handler) {
+    this._dialogHandlers.add(handler);
+  }
+  removeDialogHandler(handler) {
+    this._dialogHandlers.delete(handler);
+    if (!this._dialogHandlers.size) {
+      for (const dialog of this._openedDialogs)
+        dialog.close().catch(() => {
+        });
+    }
+  }
+  hasOpenDialogsForPage(page) {
+    return [...this._openedDialogs].some((dialog) => dialog.page() === page);
+  }
+  async closeBeforeUnloadDialogs() {
+    await Promise.all([...this._openedDialogs].map(async (dialog) => {
+      if (dialog.type() === "beforeunload")
+        await dialog.dismiss();
+    }));
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Dialog
+  Dialog,
+  DialogManager
 });

package/lib/server/dispatchers/androidDispatcher.js

@@ -26,20 +26,19 @@ module.exports = __toCommonJS(androidDispatcher_exports);
 var import_browserContextDispatcher = require("./browserContextDispatcher");
 var import_dispatcher = require("./dispatcher");
 var import_android = require("../android/android");
+var import_eventsHelper = require("../utils/eventsHelper");
+var import_instrumentation = require("../instrumentation");
 class AndroidDispatcher extends import_dispatcher.Dispatcher {
   constructor(scope, android) {
     super(scope, android, "Android", {});
     this._type_Android = true;
   }
-  async devices(params) {
-    const devices = await this._object.devices(params);
+  async devices(params, progress) {
+    const devices = await this._object.devices(progress, params);
     return {
       devices: devices.map((d) => AndroidDeviceDispatcher.from(this, d))
     };
   }
-  async setDefaultTimeoutNoReply(params) {
-    this._object.setDefaultTimeout(params.timeout);
-  }
 }
 class AndroidDeviceDispatcher extends import_dispatcher.Dispatcher {
   constructor(scope, device) {
@@ -53,49 +52,49 @@ class AndroidDeviceDispatcher extends import_dispatcher.Dispatcher {
       this._dispatchEvent("webViewAdded", { webView });
     this.addObjectListener(import_android.AndroidDevice.Events.WebViewAdded, (webView) => this._dispatchEvent("webViewAdded", { webView }));
     this.addObjectListener(import_android.AndroidDevice.Events.WebViewRemoved, (socketName) => this._dispatchEvent("webViewRemoved", { socketName }));
-    this.addObjectListener(import_android.AndroidDevice.Events.Close, (socketName) => this._dispatchEvent("close"));
+    this.addObjectListener(import_android.AndroidDevice.Events.Close, () => this._dispatchEvent("close"));
   }
   static from(scope, device) {
-    const result = (0, import_dispatcher.existingDispatcher)(device);
+    const result = scope.connection.existingDispatcher(device);
     return result || new AndroidDeviceDispatcher(scope, device);
   }
-  async wait(params) {
-    await this._object.send("wait", params);
+  async wait(params, progress) {
+    await progress.race(this._object.send("wait", params));
   }
-  async fill(params) {
-    await this._object.send("click", { selector: params.selector });
-    await this._object.send("fill", params);
+  async fill(params, progress) {
+    await progress.race(this._object.send("click", { selector: params.androidSelector }));
+    await progress.race(this._object.send("fill", params));
   }
-  async tap(params) {
-    await this._object.send("click", params);
+  async tap(params, progress) {
+    await progress.race(this._object.send("click", params));
   }
-  async drag(params) {
-    await this._object.send("drag", params);
+  async drag(params, progress) {
+    await progress.race(this._object.send("drag", params));
   }
-  async fling(params) {
-    await this._object.send("fling", params);
+  async fling(params, progress) {
+    await progress.race(this._object.send("fling", params));
   }
-  async longTap(params) {
-    await this._object.send("longClick", params);
+  async longTap(params, progress) {
+    await progress.race(this._object.send("longClick", params));
   }
-  async pinchClose(params) {
-    await this._object.send("pinchClose", params);
+  async pinchClose(params, progress) {
+    await progress.race(this._object.send("pinchClose", params));
   }
-  async pinchOpen(params) {
-    await this._object.send("pinchOpen", params);
+  async pinchOpen(params, progress) {
+    await progress.race(this._object.send("pinchOpen", params));
   }
-  async scroll(params) {
-    await this._object.send("scroll", params);
+  async scroll(params, progress) {
+    await progress.race(this._object.send("scroll", params));
   }
-  async swipe(params) {
-    await this._object.send("swipe", params);
+  async swipe(params, progress) {
+    await progress.race(this._object.send("swipe", params));
   }
-  async info(params) {
-    const info = await this._object.send("info", params);
+  async info(params, progress) {
+    const info = await progress.race(this._object.send("info", params));
     fixupAndroidElementInfo(info);
     return { info };
   }
-  async inputType(params) {
+  async inputType(params, progress) {
     const text = params.text;
     const keyCodes = [];
     for (let i = 0; i < text.length; ++i) {
@@ -104,50 +103,66 @@ class AndroidDeviceDispatcher extends import_dispatcher.Dispatcher {
         throw new Error("No mapping for " + text[i] + " found");
       keyCodes.push(code);
     }
-    await Promise.all(keyCodes.map((keyCode) => this._object.send("inputPress", { keyCode })));
+    await progress.race(Promise.all(keyCodes.map((keyCode) => this._object.send("inputPress", { keyCode }))));
   }
-  async inputPress(params) {
+  async inputPress(params, progress) {
     if (!keyMap.has(params.key))
       throw new Error("Unknown key: " + params.key);
-    await this._object.send("inputPress", { keyCode: keyMap.get(params.key) });
+    await progress.race(this._object.send("inputPress", { keyCode: keyMap.get(params.key) }));
   }
-  async inputTap(params) {
-    await this._object.send("inputClick", params);
+  async inputTap(params, progress) {
+    await progress.race(this._object.send("inputClick", params));
   }
-  async inputSwipe(params) {
-    await this._object.send("inputSwipe", params);
+  async inputSwipe(params, progress) {
+    await progress.race(this._object.send("inputSwipe", params));
   }
-  async inputDrag(params) {
-    await this._object.send("inputDrag", params);
+  async inputDrag(params, progress) {
+    await progress.race(this._object.send("inputDrag", params));
   }
-  async screenshot(params) {
-    return { binary: await this._object.screenshot() };
+  async screenshot(params, progress) {
+    return { binary: await progress.race(this._object.screenshot()) };
   }
-  async shell(params) {
-    return { result: await this._object.shell(params.command) };
+  async shell(params, progress) {
+    return { result: await progress.race(this._object.shell(params.command)) };
   }
-  async open(params, metadata) {
-    const socket = await this._object.open(params.command);
-    return { socket: new AndroidSocketDispatcher(this, socket) };
+  async open(params, progress) {
+    const socket = await this._object.open(progress, params.command);
+    return { socket: new AndroidSocketDispatcher(this, new SocketSdkObject(this._object, socket)) };
   }
-  async installApk(params) {
-    await this._object.installApk(params.file, { args: params.args });
+  async installApk(params, progress) {
+    await this._object.installApk(progress, params.file, { args: params.args });
   }
-  async push(params) {
-    await this._object.push(params.file, params.path, params.mode);
+  async push(params, progress) {
+    await progress.race(this._object.push(progress, params.file, params.path, params.mode));
   }
-  async launchBrowser(params) {
-    const context = await this._object.launchBrowser(params.pkg, params);
-    return { context: new import_browserContextDispatcher.BrowserContextDispatcher(this, context) };
+  async launchBrowser(params, progress) {
+    const context = await this._object.launchBrowser(progress, params.pkg, params);
+    return { context: import_browserContextDispatcher.BrowserContextDispatcher.from(this, context) };
   }
-  async close(params) {
+  async close(params, progress) {
     await this._object.close();
   }
-  async setDefaultTimeoutNoReply(params) {
-    this._object.setDefaultTimeout(params.timeout);
+  async connectToWebView(params, progress) {
+    return { context: import_browserContextDispatcher.BrowserContextDispatcher.from(this, await this._object.connectToWebView(progress, params.socketName)) };
   }
-  async connectToWebView(params) {
-    return { context: new import_browserContextDispatcher.BrowserContextDispatcher(this, await this._object.connectToWebView(params.socketName)) };
+}
+class SocketSdkObject extends import_instrumentation.SdkObject {
+  constructor(parent, socket) {
+    super(parent, "socket");
+    this._socket = socket;
+    this._eventListeners = [
+      import_eventsHelper.eventsHelper.addEventListener(socket, "data", (data) => this.emit("data", data)),
+      import_eventsHelper.eventsHelper.addEventListener(socket, "close", () => {
+        import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
+        this.emit("close");
+      })
+    ];
+  }
+  async write(data) {
+    await this._socket.write(data);
+  }
+  close() {
+    this._socket.close();
   }
 }
 class AndroidSocketDispatcher extends import_dispatcher.Dispatcher {
@@ -160,10 +175,10 @@ class AndroidSocketDispatcher extends import_dispatcher.Dispatcher {
       this._dispose();
     });
   }
-  async write(params, metadata) {
-    await this._object.write(params.data);
+  async write(params, progress) {
+    await progress.race(this._object.write(params.data));
   }
-  async close(params, metadata) {
+  async close(params, progress) {
     this._object.close();
   }
 }

package/lib/server/dispatchers/artifactDispatcher.js

@@ -48,15 +48,15 @@ class ArtifactDispatcher extends import_dispatcher.Dispatcher {
   static fromNullable(parentScope, artifact) {
     if (!artifact)
       return void 0;
-    const result = (0, import_dispatcher.existingDispatcher)(artifact);
+    const result = parentScope.connection.existingDispatcher(artifact);
     return result || new ArtifactDispatcher(parentScope, artifact);
   }
-  async pathAfterFinished() {
-    const path = await this._object.localPathAfterFinished();
+  async pathAfterFinished(params, progress) {
+    const path = await progress.race(this._object.localPathAfterFinished());
     return { value: path };
   }
-  async saveAs(params) {
-    return await new Promise((resolve, reject) => {
+  async saveAs(params, progress) {
+    return await progress.race(new Promise((resolve, reject) => {
       this._object.saveAs(async (localPath, error) => {
         if (error) {
           reject(error);
@@ -70,10 +70,10 @@ class ArtifactDispatcher extends import_dispatcher.Dispatcher {
           reject(e);
         }
       });
-    });
+    }));
   }
-  async saveAsStream() {
-    return await new Promise((resolve, reject) => {
+  async saveAsStream(params, progress) {
+    return await progress.race(new Promise((resolve, reject) => {
       this._object.saveAs(async (localPath, error) => {
         if (error) {
           reject(error);
@@ -92,23 +92,23 @@ class ArtifactDispatcher extends import_dispatcher.Dispatcher {
           reject(e);
         }
       });
-    });
+    }));
   }
-  async stream() {
-    const fileName = await this._object.localPathAfterFinished();
+  async stream(params, progress) {
+    const fileName = await progress.race(this._object.localPathAfterFinished());
     const readable = import_fs.default.createReadStream(fileName, { highWaterMark: 1024 * 1024 });
     return { stream: new import_streamDispatcher.StreamDispatcher(this, readable) };
   }
-  async failure() {
-    const error = await this._object.failureError();
+  async failure(params, progress) {
+    const error = await progress.race(this._object.failureError());
     return { error: error || void 0 };
   }
-  async cancel() {
-    await this._object.cancel();
+  async cancel(params, progress) {
+    await progress.race(this._object.cancel());
   }
-  async delete(_, metadata) {
-    metadata.potentiallyClosesScope = true;
-    await this._object.delete();
+  async delete(params, progress) {
+    progress.metadata.potentiallyClosesScope = true;
+    await progress.race(this._object.delete());
     this._dispose();
   }
 }