patchright-core 1.52.5 → 1.55.0

package/lib/server/har/harRecorder.js

@@ -46,7 +46,7 @@ class HarRecorder {
     this._writtenZipEntries = /* @__PURE__ */ new Set();
     this._artifact = new import_artifact.Artifact(context, import_path.default.join(context._browser.options.artifactsDir, `${(0, import_crypto.createGuid)()}.har`));
     const urlFilterRe = options.urlRegexSource !== void 0 && options.urlRegexFlags !== void 0 ? new RegExp(options.urlRegexSource, options.urlRegexFlags) : void 0;
-    const expectsZip = options.path.endsWith(".zip");
+    const expectsZip = !!options.zip;
     const content = options.content || (expectsZip ? "attach" : "embed");
     this._tracer = new import_harTracer.HarTracer(context, page, this, {
       content,

package/lib/server/har/harTracer.js

@@ -85,6 +85,8 @@ class HarTracer {
         import_eventsHelper.eventsHelper.addEventListener(this._context, import_browserContext.BrowserContext.Events.RequestFulfilled, (request) => this._onRequestFulfilled(request)),
         import_eventsHelper.eventsHelper.addEventListener(this._context, import_browserContext.BrowserContext.Events.RequestContinued, (request) => this._onRequestContinued(request))
       );
+      for (const page of this._context.pages())
+        this._createPageEntryIfNeeded(page);
     }
   }
   _shouldIncludeEntryWithUrl(urlString) {
@@ -250,7 +252,7 @@ class HarTracer {
     harEntry.request.headers = headers;
   }
   _recordRequestOverrides(harEntry, request) {
-    if (!request._hasOverrides() || !this._options.recordRequestOverrides)
+    if (!request.overrides() || !this._options.recordRequestOverrides)
       return;
     harEntry.request.method = request.method();
     harEntry.request.url = request.url();
@@ -390,7 +392,7 @@ class HarTracer {
       status: response.status(),
       statusText: response.statusText(),
       httpVersion: response.httpVersion(),
-      // These are bad values that will be overwritten bellow.
+      // These are bad values that will be overwritten below.
       cookies: [],
       headers: [],
       content: {

package/lib/server/helper.js

@@ -51,22 +51,18 @@ class Helper {
   }
   static waitForEvent(progress, emitter, event, predicate) {
     const listeners = [];
-    const promise = new Promise((resolve, reject) => {
+    const dispose = () => import_eventsHelper.eventsHelper.removeEventListeners(listeners);
+    const promise = progress.race(new Promise((resolve, reject) => {
       listeners.push(import_eventsHelper.eventsHelper.addEventListener(emitter, event, (eventArg) => {
         try {
           if (predicate && !predicate(eventArg))
             return;
-          import_eventsHelper.eventsHelper.removeEventListeners(listeners);
           resolve(eventArg);
         } catch (e) {
-          import_eventsHelper.eventsHelper.removeEventListeners(listeners);
           reject(e);
         }
       }));
-    });
-    const dispose = () => import_eventsHelper.eventsHelper.removeEventListeners(listeners);
-    if (progress)
-      progress.cleanupWhenAborted(dispose);
+    })).finally(() => dispose());
     return { promise, dispose };
   }
   static secondsToRoundishMillis(value) {

package/lib/server/index.js

@@ -30,7 +30,6 @@ __export(server_exports, {
   registry: () => import_registry.registry,
   registryDirectory: () => import_registry.registryDirectory,
   runTraceViewerApp: () => import_traceViewer.runTraceViewerApp,
-  serverSideCallMetadata: () => import_instrumentation.serverSideCallMetadata,
   startTraceViewerServer: () => import_traceViewer.startTraceViewerServer,
   writeDockerVersion: () => import_registry.writeDockerVersion
 });
@@ -40,7 +39,6 @@ var import_dispatcher = require("./dispatchers/dispatcher");
 var import_playwrightDispatcher = require("./dispatchers/playwrightDispatcher");
 var import_playwright = require("./playwright");
 var import_traceViewer = require("./trace/viewer/traceViewer");
-var import_instrumentation = require("./instrumentation");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DispatcherConnection,
@@ -55,7 +53,6 @@ var import_instrumentation = require("./instrumentation");
   registry,
   registryDirectory,
   runTraceViewerApp,
-  serverSideCallMetadata,
   startTraceViewerServer,
   writeDockerVersion
 });

package/lib/server/input.js

@@ -38,55 +38,58 @@ __export(input_exports, {
 module.exports = __toCommonJS(input_exports);
 var import_utils = require("../utils");
 var keyboardLayout = __toESM(require("./usKeyboardLayout"));
+var import_dom = require("./dom");
 const keypadLocation = keyboardLayout.keypadLocation;
 const kModifiers = ["Alt", "Control", "Meta", "Shift"];
 class Keyboard {
-  constructor(raw) {
+  constructor(raw, page) {
     this._pressedModifiers = /* @__PURE__ */ new Set();
     this._pressedKeys = /* @__PURE__ */ new Set();
     this._raw = raw;
+    this._page = page;
   }
-  async down(key) {
+  async down(progress, key) {
     const description = this._keyDescriptionForString(key);
     const autoRepeat = this._pressedKeys.has(description.code);
     this._pressedKeys.add(description.code);
     if (kModifiers.includes(description.key))
       this._pressedModifiers.add(description.key);
-    await this._raw.keydown(this._pressedModifiers, key, description, autoRepeat);
+    await this._raw.keydown(progress, this._pressedModifiers, key, description, autoRepeat);
   }
   _keyDescriptionForString(str) {
     const keyString = resolveSmartModifierString(str);
     let description = usKeyboardLayout.get(keyString);
-    (0, import_utils.assert)(description, `Unknown key: "${keyString}"`);
+    if (!description)
+      throw new import_dom.NonRecoverableDOMError(`Unknown key: "${keyString}"`);
     const shift = this._pressedModifiers.has("Shift");
     description = shift && description.shifted ? description.shifted : description;
     if (this._pressedModifiers.size > 1 || !this._pressedModifiers.has("Shift") && this._pressedModifiers.size === 1)
       return { ...description, text: "" };
     return description;
   }
-  async up(key) {
+  async up(progress, key) {
     const description = this._keyDescriptionForString(key);
     if (kModifiers.includes(description.key))
       this._pressedModifiers.delete(description.key);
     this._pressedKeys.delete(description.code);
-    await this._raw.keyup(this._pressedModifiers, key, description);
+    await this._raw.keyup(progress, this._pressedModifiers, key, description);
   }
-  async insertText(text) {
-    await this._raw.sendText(text);
+  async insertText(progress, text) {
+    await this._raw.sendText(progress, text);
   }
-  async type(text, options) {
+  async type(progress, text, options) {
     const delay = options && options.delay || void 0;
     for (const char of text) {
       if (usKeyboardLayout.has(char)) {
-        await this.press(char, { delay });
+        await this.press(progress, char, { delay });
       } else {
         if (delay)
-          await new Promise((f) => setTimeout(f, delay));
-        await this.insertText(char);
+          await progress.wait(delay);
+        await this.insertText(progress, char);
       }
     }
   }
-  async press(key, options = {}) {
+  async press(progress, key, options = {}) {
     function split(keyString) {
       const keys = [];
       let building = "";
@@ -104,15 +107,15 @@ class Keyboard {
     const tokens = split(key);
     key = tokens[tokens.length - 1];
     for (let i = 0; i < tokens.length - 1; ++i)
-      await this.down(tokens[i]);
-    await this.down(key);
+      await this.down(progress, tokens[i]);
+    await this.down(progress, key);
     if (options.delay)
-      await new Promise((f) => setTimeout(f, options.delay));
-    await this.up(key);
+      await progress.wait(options.delay);
+    await this.up(progress, key);
     for (let i = tokens.length - 2; i >= 0; --i)
-      await this.up(tokens[i]);
+      await this.up(progress, tokens[i]);
   }
-  async ensureModifiers(mm) {
+  async ensureModifiers(progress, mm) {
     const modifiers = mm.map(resolveSmartModifier);
     for (const modifier of modifiers) {
       if (!kModifiers.includes(modifier))
@@ -123,9 +126,9 @@ class Keyboard {
       const needDown = modifiers.includes(key);
       const isDown = this._pressedModifiers.has(key);
       if (needDown && !isDown)
-        await this.down(key);
+        await this.down(progress, key);
       else if (!needDown && isDown)
-        await this.up(key);
+        await this.up(progress, key);
     }
     return restore;
   }
@@ -151,9 +154,10 @@ class Mouse {
     this._page = page;
     this._keyboard = this._page.keyboard;
   }
-  async move(x, y, options = {}, metadata) {
-    if (metadata)
-      metadata.point = { x, y };
+  currentPoint() {
+    return { x: this._x, y: this._y };
+  }
+  async move(progress, x, y, options = {}) {
     const { steps = 1 } = options;
     const fromX = this._x;
     const fromY = this._y;
@@ -162,53 +166,44 @@ class Mouse {
     for (let i = 1; i <= steps; i++) {
       const middleX = fromX + (x - fromX) * (i / steps);
       const middleY = fromY + (y - fromY) * (i / steps);
-      await this._raw.move(middleX, middleY, this._lastButton, this._buttons, this._keyboard._modifiers(), !!options.forClick);
+      await this._raw.move(progress, middleX, middleY, this._lastButton, this._buttons, this._keyboard._modifiers(), !!options.forClick);
     }
   }
-  async down(options = {}, metadata) {
-    if (metadata)
-      metadata.point = { x: this._x, y: this._y };
+  async down(progress, options = {}) {
     const { button = "left", clickCount = 1 } = options;
     this._lastButton = button;
     this._buttons.add(button);
-    await this._raw.down(this._x, this._y, this._lastButton, this._buttons, this._keyboard._modifiers(), clickCount);
+    await this._raw.down(progress, this._x, this._y, this._lastButton, this._buttons, this._keyboard._modifiers(), clickCount);
   }
-  async up(options = {}, metadata) {
-    if (metadata)
-      metadata.point = { x: this._x, y: this._y };
+  async up(progress, options = {}) {
     const { button = "left", clickCount = 1 } = options;
     this._lastButton = "none";
     this._buttons.delete(button);
-    await this._raw.up(this._x, this._y, button, this._buttons, this._keyboard._modifiers(), clickCount);
+    await this._raw.up(progress, this._x, this._y, button, this._buttons, this._keyboard._modifiers(), clickCount);
   }
-  async click(x, y, options = {}, metadata) {
-    if (metadata)
-      metadata.point = { x, y };
+  async click(progress, x, y, options = {}) {
     const { delay = null, clickCount = 1 } = options;
     if (delay) {
-      this.move(x, y, { forClick: true });
+      this.move(progress, x, y, { forClick: true });
       for (let cc = 1; cc <= clickCount; ++cc) {
-        await this.down({ ...options, clickCount: cc });
-        await new Promise((f) => setTimeout(f, delay));
-        await this.up({ ...options, clickCount: cc });
+        await this.down(progress, { ...options, clickCount: cc });
+        await progress.wait(delay);
+        await this.up(progress, { ...options, clickCount: cc });
         if (cc < clickCount)
-          await new Promise((f) => setTimeout(f, delay));
+          await progress.wait(delay);
       }
     } else {
       const promises = [];
-      promises.push(this.move(x, y, { forClick: true }));
+      promises.push(this.move(progress, x, y, { forClick: true }));
       for (let cc = 1; cc <= clickCount; ++cc) {
-        promises.push(this.down({ ...options, clickCount: cc }));
-        promises.push(this.up({ ...options, clickCount: cc }));
+        promises.push(this.down(progress, { ...options, clickCount: cc }));
+        promises.push(this.up(progress, { ...options, clickCount: cc }));
       }
       await Promise.all(promises);
     }
   }
-  async dblclick(x, y, options = {}) {
-    await this.click(x, y, { ...options, clickCount: 2 });
-  }
-  async wheel(deltaX, deltaY) {
-    await this._raw.wheel(this._x, this._y, this._buttons, this._keyboard._modifiers(), deltaX, deltaY);
+  async wheel(progress, deltaX, deltaY) {
+    await this._raw.wheel(progress, this._x, this._y, this._buttons, this._keyboard._modifiers(), deltaX, deltaY);
   }
 }
 const aliases = /* @__PURE__ */ new Map([
@@ -261,12 +256,10 @@ class Touchscreen {
     this._raw = raw;
     this._page = page;
   }
-  async tap(x, y, metadata) {
-    if (metadata)
-      metadata.point = { x, y };
-    if (!this._page._browserContext._options.hasTouch)
+  async tap(progress, x, y) {
+    if (!this._page.browserContext._options.hasTouch)
       throw new Error("hasTouch must be enabled on the browser context before using the touchscreen.");
-    await this._raw.tap(x, y, this._page.keyboard._modifiers());
+    await this._raw.tap(progress, x, y, this._page.keyboard._modifiers());
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/instrumentation.js

@@ -20,7 +20,7 @@ var instrumentation_exports = {};
 __export(instrumentation_exports, {
   SdkObject: () => SdkObject,
   createInstrumentation: () => createInstrumentation,
-  serverSideCallMetadata: () => serverSideCallMetadata
+  createRootSdkObject: () => createRootSdkObject
 });
 module.exports = __toCommonJS(instrumentation_exports);
 var import_events = require("events");
@@ -34,6 +34,12 @@ class SdkObject extends import_events.EventEmitter {
     this.instrumentation = parent.instrumentation;
   }
 }
+function createRootSdkObject() {
+  const fakeParent = { attribution: {}, instrumentation: createInstrumentation() };
+  const root = new SdkObject(fakeParent);
+  root.guid = "";
+  return root;
+}
 function createInstrumentation() {
   const listeners = /* @__PURE__ */ new Map();
   return new Proxy({}, {
@@ -55,21 +61,9 @@ function createInstrumentation() {
     }
   });
 }
-function serverSideCallMetadata() {
-  return {
-    id: "",
-    startTime: 0,
-    endTime: 0,
-    type: "Internal",
-    method: "",
-    params: {},
-    log: [],
-    isServerSide: true
-  };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SdkObject,
   createInstrumentation,
-  serverSideCallMetadata
+  createRootSdkObject
 });

package/lib/server/javascript.js

@@ -35,21 +35,15 @@ __export(javascript_exports, {
   evaluateExpression: () => evaluateExpression,
   isJavaScriptErrorInEvaluate: () => isJavaScriptErrorInEvaluate,
   normalizeEvaluationExpression: () => normalizeEvaluationExpression,
-  parseEvaluationResultValue: () => parseEvaluationResultValue,
   parseUnserializableValue: () => parseUnserializableValue,
-  serializeAsCallArgument: () => serializeAsCallArgument,
   sparseArrayToString: () => sparseArrayToString
 });
 module.exports = __toCommonJS(javascript_exports);
 var import_instrumentation = require("./instrumentation");
-var utilityScriptSource = __toESM(require("../generated/utilityScriptSource"));
+var rawUtilityScriptSource = __toESM(require("../generated/utilityScriptSource"));
 var import_utils = require("../utils");
-var import_builtins = require("../utils/isomorphic/builtins");
 var import_utilityScriptSerializers = require("../utils/isomorphic/utilityScriptSerializers");
 var import_manualPromise = require("../utils/isomorphic/manualPromise");
-const utilityScriptSerializers = (0, import_utilityScriptSerializers.source)((0, import_builtins.builtins)());
-const parseEvaluationResultValue = utilityScriptSerializers.parseEvaluationResultValue;
-const serializeAsCallArgument = utilityScriptSerializers.serializeAsCallArgument;
 class ExecutionContext extends import_instrumentation.SdkObject {
   constructor(parent, delegate, worldNameForTest) {
     super(parent, "execution-context");
@@ -70,7 +64,7 @@ class ExecutionContext extends import_instrumentation.SdkObject {
     return this._raceAgainstContextDestroyed(this.delegate.rawEvaluateHandle(this, expression));
   }
   async evaluateWithArguments(expression, returnByValue, values, handles) {
-    const utilityScript = await this._utilityScript();
+    const utilityScript = await this.utilityScript();
     return this._raceAgainstContextDestroyed(this.delegate.evaluateWithArguments(expression, returnByValue, utilityScript, values, handles));
   }
   getProperties(object) {
@@ -82,15 +76,15 @@ class ExecutionContext extends import_instrumentation.SdkObject {
   adoptIfNeeded(handle) {
     return null;
   }
-  _utilityScript() {
+  utilityScript() {
     if (!this._utilityScriptPromise) {
-      const source2 = `
+      const source = `
       (() => {
         const module = {};
-        ${utilityScriptSource.source}
-        return new (module.exports.UtilityScript())(${(0, import_utils.isUnderTest)()});
+        ${rawUtilityScriptSource.source}
+        return new (module.exports.UtilityScript())(globalThis, ${(0, import_utils.isUnderTest)()});
       })();`;
-      this._utilityScriptPromise = this._raceAgainstContextDestroyed(this.delegate.rawEvaluateHandle(this, source2)).then((handle) => {
+      this._utilityScriptPromise = this._raceAgainstContextDestroyed(this.delegate.rawEvaluateHandle(this, source)).then((handle) => {
         handle._setPreview("UtilityScript");
         return handle;
       });
@@ -213,7 +207,7 @@ async function evaluateExpression(context, expression, options, ...args) {
     handles.push(handle);
     return handles.length - 1;
   };
-  args = args.map((arg) => serializeAsCallArgument(arg, (handle) => {
+  args = args.map((arg) => (0, import_utilityScriptSerializers.serializeAsCallArgument)(arg, (handle) => {
     if (handle instanceof JSHandle) {
       if (!handle._objectId)
         return { fallThrough: handle._value };
@@ -308,8 +302,6 @@ function sparseArrayToString(entries) {
   evaluateExpression,
   isJavaScriptErrorInEvaluate,
   normalizeEvaluationExpression,
-  parseEvaluationResultValue,
   parseUnserializableValue,
-  serializeAsCallArgument,
   sparseArrayToString
 });

package/lib/server/launchApp.js

@@ -35,9 +35,9 @@ module.exports = __toCommonJS(launchApp_exports);
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_utils = require("../utils");
-var import_instrumentation = require("./instrumentation");
 var import_registry = require("./registry");
 var import_registry2 = require("./registry");
+var import_progress = require("./progress");
 async function launchApp(browserType, options) {
   const args = [...options.persistentContextOptions?.args ?? []];
   let channel = options.persistentContextOptions?.channel;
@@ -49,23 +49,37 @@ async function launchApp(browserType, options) {
       "--test-type="
     );
     if (!channel && !options.persistentContextOptions?.executablePath)
-      channel = (0, import_registry.findChromiumChannel)(options.sdkLanguage);
+      channel = (0, import_registry.findChromiumChannelBestEffort)(options.sdkLanguage);
+  }
+  const controller = new import_progress.ProgressController();
+  let context;
+  try {
+    context = await controller.run((progress) => browserType.launchPersistentContext(progress, "", {
+      ignoreDefaultArgs: ["--enable-automation"],
+      ...options?.persistentContextOptions,
+      channel,
+      noDefaultViewport: options.persistentContextOptions?.noDefaultViewport ?? true,
+      acceptDownloads: options?.persistentContextOptions?.acceptDownloads ?? ((0, import_utils.isUnderTest)() ? "accept" : "internal-browser-default"),
+      colorScheme: options?.persistentContextOptions?.colorScheme ?? "no-override",
+      args
+    }), 0);
+  } catch (error) {
+    if (channel) {
+      error = (0, import_utils.rewriteErrorMessage)(error, [
+        `Failed to launch "${channel}" channel.`,
+        "Using custom channels could lead to unexpected behavior due to Enterprise policies (chrome://policy).",
+        "Install the default browser instead:",
+        (0, import_utils.wrapInASCIIBox)(`${(0, import_registry.buildPlaywrightCLICommand)(options.sdkLanguage, "install")}`, 2)
+      ].join("\n"));
+    }
+    throw error;
   }
-  const context = await browserType.launchPersistentContext((0, import_instrumentation.serverSideCallMetadata)(), "", {
-    ignoreDefaultArgs: ["--enable-automation"],
-    ...options?.persistentContextOptions,
-    channel,
-    noDefaultViewport: options.persistentContextOptions?.noDefaultViewport ?? true,
-    acceptDownloads: options?.persistentContextOptions?.acceptDownloads ?? ((0, import_utils.isUnderTest)() ? "accept" : "internal-browser-default"),
-    colorScheme: options?.persistentContextOptions?.colorScheme ?? "no-override",
-    args
-  });
   const [page] = context.pages();
   if (browserType.name() === "chromium" && process.platform === "darwin") {
     context.on("page", async (newPage) => {
       if (newPage.mainFrame().url() === "chrome://new-tab-page/") {
         await page.bringToFront();
-        await newPage.close((0, import_instrumentation.serverSideCallMetadata)());
+        await newPage.close();
       }
     });
   }
@@ -75,7 +89,7 @@ async function launchApp(browserType, options) {
 }
 async function installAppIcon(page) {
   const icon = await import_fs.default.promises.readFile(require.resolve("./chromium/appIcon.png"));
-  const crPage = page._delegate;
+  const crPage = page.delegate;
   await crPage._mainFrameSession._client.send("Browser.setDockTile", {
     image: icon.toString("base64")
   });
@@ -84,24 +98,28 @@ async function syncLocalStorageWithSettings(page, appName) {
   if ((0, import_utils.isUnderTest)())
     return;
   const settingsFile = import_path.default.join(import_registry2.registryDirectory, ".settings", `${appName}.json`);
-  await page.exposeBinding("_saveSerializedSettings", false, (_, settings2) => {
-    import_fs.default.mkdirSync(import_path.default.dirname(settingsFile), { recursive: true });
-    import_fs.default.writeFileSync(settingsFile, settings2);
+  const controller = new import_progress.ProgressController();
+  await controller.run(async (progress) => {
+    await page.exposeBinding(progress, "_saveSerializedSettings", false, (_, settings2) => {
+      import_fs.default.mkdirSync(import_path.default.dirname(settingsFile), { recursive: true });
+      import_fs.default.writeFileSync(settingsFile, settings2);
+    });
+    const settings = await import_fs.default.promises.readFile(settingsFile, "utf-8").catch(() => "{}");
+    await page.addInitScript(
+      progress,
+      `(${String((settings2) => {
+        if (location && location.protocol === "data:")
+          return;
+        if (window.top !== window)
+          return;
+        Object.entries(settings2).map(([k, v]) => localStorage[k] = v);
+        window.saveSettings = () => {
+          window._saveSerializedSettings(JSON.stringify({ ...localStorage }));
+        };
+      })})(${settings});
+    `
+    );
   });
-  const settings = await import_fs.default.promises.readFile(settingsFile, "utf-8").catch(() => "{}");
-  await page.addInitScript(
-    `(${String((settings2) => {
-      if (location && location.protocol === "data:")
-        return;
-      if (window.top !== window)
-        return;
-      Object.entries(settings2).map(([k, v]) => localStorage[k] = v);
-      window.saveSettings = () => {
-        window._saveSerializedSettings(JSON.stringify({ ...localStorage }));
-      };
-    })})(${settings});
-  `
-  );
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {