patchright-core 1.52.5 → 1.55.1

package/lib/server/pageBinding.js

@@ -23,10 +23,9 @@ __export(pageBinding_exports, {
   takeBindingHandle: () => takeBindingHandle
 });
 module.exports = __toCommonJS(pageBinding_exports);
-var import_builtins = require("../utils/isomorphic/builtins");
-var import_utilityScriptSerializers = require("../utils/isomorphic/utilityScriptSerializers");
-function addPageBinding(bindingName, needsHandle, utilityScriptSerializersFactory, builtins2) {
-  const { serializeAsCallArgument } = utilityScriptSerializersFactory(builtins2);
+var import_oldUtilityScriptSerializers = require("../utils/isomorphic/oldUtilityScriptSerializers");
+function addPageBinding(bindingName, needsHandle, utilityScriptSerializersFactory) {
+  const { serializeAsCallArgument } = utilityScriptSerializersFactory;
   const binding = globalThis[bindingName];
   if (!binding || binding.toString().startsWith("(...args) => {")) return;
   globalThis[bindingName] = (...args) => {
@@ -35,14 +34,14 @@ function addPageBinding(bindingName, needsHandle, utilityScriptSerializersFactor
       throw new Error(`exposeBindingHandle supports a single argument, ${args.length} received`);
     let callbacks = me["callbacks"];
     if (!callbacks) {
-      callbacks = new builtins2.Map();
+      callbacks = /* @__PURE__ */ new Map();
       me["callbacks"] = callbacks;
     }
     const seq = (me["lastSeq"] || 0) + 1;
     me["lastSeq"] = seq;
     let handles = me["handles"];
     if (!handles) {
-      handles = new builtins2.Map();
+      handles = /* @__PURE__ */ new Map();
       me["handles"] = handles;
     }
     const promise = new Promise((resolve, reject) => callbacks.set(seq, { resolve, reject }));
@@ -78,7 +77,7 @@ function deliverBindingResult(arg) {
   callbacks.delete(arg.seq);
 }
 function createPageBindingScript(name, needsHandle) {
-  return `(${addPageBinding.toString()})(${JSON.stringify(name)}, ${needsHandle}, (${import_utilityScriptSerializers.source}), (${import_builtins.builtins})())`;
+  return `(${addPageBinding.toString()})(${JSON.stringify(name)}, ${needsHandle}, (${import_oldUtilityScriptSerializers.source})())`;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/playwright.js

@@ -22,7 +22,6 @@ __export(playwright_exports, {
   createPlaywright: () => createPlaywright
 });
 module.exports = __toCommonJS(playwright_exports);
-var import_utils = require("../utils");
 var import_android = require("./android/android");
 var import_backendAdb = require("./android/backendAdb");
 var import_bidiChromium = require("./bidi/bidiChromium");
@@ -32,11 +31,10 @@ var import_debugController = require("./debugController");
 var import_electron = require("./electron/electron");
 var import_firefox = require("./firefox/firefox");
 var import_instrumentation = require("./instrumentation");
-var import_selectors = require("./selectors");
 var import_webkit = require("./webkit/webkit");
 class Playwright extends import_instrumentation.SdkObject {
   constructor(options) {
-    super({ attribution: {}, instrumentation: (0, import_instrumentation.createInstrumentation)() }, void 0, "Playwright");
+    super((0, import_instrumentation.createRootSdkObject)(), void 0, "Playwright");
     this._allPages = /* @__PURE__ */ new Set();
     this._allBrowsers = /* @__PURE__ */ new Set();
     this.options = options;
@@ -45,25 +43,17 @@ class Playwright extends import_instrumentation.SdkObject {
       onBrowserOpen: (browser) => this._allBrowsers.add(browser),
       onBrowserClose: (browser) => this._allBrowsers.delete(browser),
       onPageOpen: (page) => this._allPages.add(page),
-      onPageClose: (page) => this._allPages.delete(page),
-      onCallLog: (sdkObject, metadata, logName, message) => {
-        import_utils.debugLogger.log(logName, message);
-      }
+      onPageClose: (page) => this._allPages.delete(page)
     }, null);
     this.chromium = new import_chromium.Chromium(this);
-    this.bidiChromium = new import_bidiChromium.BidiChromium(this);
-    this.bidiFirefox = new import_bidiFirefox.BidiFirefox(this);
+    this._bidiChromium = new import_bidiChromium.BidiChromium(this);
+    this._bidiFirefox = new import_bidiFirefox.BidiFirefox(this);
     this.firefox = new import_firefox.Firefox(this);
     this.webkit = new import_webkit.WebKit(this);
     this.electron = new import_electron.Electron(this);
     this.android = new import_android.Android(this, new import_backendAdb.AdbBackend());
-    this.selectors = new import_selectors.Selectors();
     this.debugController = new import_debugController.DebugController(this);
   }
-  async hideHighlight() {
-    await Promise.all([...this._allPages].map((p) => p.hideHighlight().catch(() => {
-    })));
-  }
   allBrowsers() {
     return [...this._allBrowsers];
   }

package/lib/server/progress.js

@@ -18,87 +18,95 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var progress_exports = {};
 __export(progress_exports, {
-  ProgressController: () => ProgressController
+  ProgressController: () => ProgressController,
+  isAbortError: () => isAbortError,
+  raceUncancellableOperationWithCleanup: () => raceUncancellableOperationWithCleanup
 });
 module.exports = __toCommonJS(progress_exports);
 var import_errors = require("./errors");
 var import_utils = require("../utils");
 var import_manualPromise = require("../utils/isomorphic/manualPromise");
 class ProgressController {
-  constructor(metadata, sdkObject) {
+  constructor(metadata, onCallLog) {
     this._forceAbortPromise = new import_manualPromise.ManualPromise();
-    // Cleanups to be run only in the case of abort.
-    this._cleanups = [];
-    this._logName = "api";
+    this._donePromise = new import_manualPromise.ManualPromise();
     this._state = "before";
-    this._deadline = 0;
-    this._timeout = 0;
-    this.metadata = metadata;
-    this.sdkObject = sdkObject;
-    this.instrumentation = sdkObject.instrumentation;
+    this.metadata = metadata || { id: "", startTime: 0, endTime: 0, type: "Internal", method: "", params: {}, log: [], internal: true };
+    this._onCallLog = onCallLog;
     this._forceAbortPromise.catch((e) => null);
   }
-  setLogName(logName) {
-    this._logName = logName;
-  }
-  abort(error) {
-    this._forceAbortPromise.reject(error);
+  async abort(error) {
+    if (this._state === "running") {
+      error[kAbortErrorSymbol] = true;
+      this._state = { error };
+      this._forceAbortPromise.reject(error);
+    }
+    await this._donePromise;
   }
   async run(task, timeout) {
-    if (timeout) {
-      this._timeout = timeout;
-      this._deadline = timeout ? (0, import_utils.monotonicTime)() + timeout : 0;
-    }
     (0, import_utils.assert)(this._state === "before");
     this._state = "running";
-    this.sdkObject.attribution.context?._activeProgressControllers.add(this);
     const progress = {
       log: (message) => {
         if (this._state === "running")
           this.metadata.log.push(message);
-        this.instrumentation.onCallLog(this.sdkObject, this.metadata, this._logName, message);
-      },
-      timeUntilDeadline: () => this._deadline ? this._deadline - (0, import_utils.monotonicTime)() : 2147483647,
-      // 2^31-1 safe setTimeout in Node.
-      isRunning: () => this._state === "running",
-      cleanupWhenAborted: (cleanup) => {
-        if (this._state === "running")
-          this._cleanups.push(cleanup);
-        else
-          runCleanup(cleanup);
+        this._onCallLog?.(message);
       },
-      throwIfAborted: () => {
-        if (this._state === "aborted")
-          throw new AbortedError();
+      metadata: this.metadata,
+      race: (promise) => {
+        const promises = Array.isArray(promise) ? promise : [promise];
+        return Promise.race([...promises, this._forceAbortPromise]);
       },
-      metadata: this.metadata
+      wait: async (timeout2) => {
+        let timer2;
+        const promise = new Promise((f) => timer2 = setTimeout(f, timeout2));
+        return progress.race(promise).finally(() => clearTimeout(timer2));
+      }
     };
-    const timeoutError = new import_errors.TimeoutError(`Timeout ${this._timeout}ms exceeded.`);
-    const timer = setTimeout(() => this._forceAbortPromise.reject(timeoutError), progress.timeUntilDeadline());
+    let timer;
+    if (timeout) {
+      const timeoutError = new import_errors.TimeoutError(`Timeout ${timeout}ms exceeded.`);
+      timer = setTimeout(() => {
+        if (this._state === "running") {
+          timeoutError[kAbortErrorSymbol] = true;
+          this._state = { error: timeoutError };
+          this._forceAbortPromise.reject(timeoutError);
+        }
+      }, timeout);
+    }
     try {
-      const promise = task(progress);
-      const result = await Promise.race([promise, this._forceAbortPromise]);
+      const result = await task(progress);
       this._state = "finished";
       return result;
-    } catch (e) {
-      this._state = "aborted";
-      await Promise.all(this._cleanups.splice(0).map(runCleanup));
-      throw e;
+    } catch (error) {
+      this._state = { error };
+      throw error;
     } finally {
-      this.sdkObject.attribution.context?._activeProgressControllers.delete(this);
       clearTimeout(timer);
+      this._donePromise.resolve();
     }
   }
 }
-async function runCleanup(cleanup) {
+const kAbortErrorSymbol = Symbol("kAbortError");
+function isAbortError(error) {
+  return !!error[kAbortErrorSymbol];
+}
+async function raceUncancellableOperationWithCleanup(progress, run, cleanup) {
+  let aborted = false;
   try {
-    await cleanup();
-  } catch (e) {
+    return await progress.race(run().then(async (t) => {
+      if (aborted)
+        await cleanup(t);
+      return t;
+    }));
+  } catch (error) {
+    aborted = true;
+    throw error;
   }
 }
-class AbortedError extends Error {
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ProgressController
+  ProgressController,
+  isAbortError,
+  raceUncancellableOperationWithCleanup
 });