patchright-core 1.58.2 → 1.59.0

package/lib/server/clock.js

@@ -38,82 +38,74 @@ class Clock {
     this._browserContext = browserContext;
   }
   async uninstall(progress) {
-    await progress.race(this._browserContext.removeInitScripts(this._initScripts));
+    await progress.race(Promise.all(this._initScripts.map((script) => script.dispose())));
     this._initScripts = [];
   }
-  async fastForward(progress, ticks) {
-    await this._installIfNeeded(progress);
+  async fastForward(ticks) {
+    await this._installIfNeeded();
     const ticksMillis = parseTicks(ticks);
-    this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('fastForward', ${Date.now()}, ${ticksMillis})`));
-    await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.fastForward(${ticksMillis})`));
+    this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('fastForward', ${Date.now()}, ${ticksMillis})`));
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.fastForward(${ticksMillis})`);
   }
-  async install(progress, time) {
-    await this._installIfNeeded(progress);
+  async install(time) {
+    await this._installIfNeeded();
     const timeMillis = time !== void 0 ? parseTime(time) : Date.now();
-    this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('install', ${Date.now()}, ${timeMillis})`));
-    await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.install(${timeMillis})`));
+    this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('install', ${Date.now()}, ${timeMillis})`));
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.install(${timeMillis})`);
   }
-  async pauseAt(progress, ticks) {
-    await this._installIfNeeded(progress);
+  async pauseAt(ticks) {
+    await this._installIfNeeded();
     const timeMillis = parseTime(ticks);
-    this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('pauseAt', ${Date.now()}, ${timeMillis})`));
-    await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.pauseAt(${timeMillis})`));
+    this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('pauseAt', ${Date.now()}, ${timeMillis})`));
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.pauseAt(${timeMillis})`);
   }
   resumeNoReply() {
     if (!this._initScripts.length)
       return;
     const doResume = async () => {
-      this._initScripts.push(await this._browserContext.addInitScript(void 0, `globalThis.__pwClock.controller.log('resume', ${Date.now()})`));
+      this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('resume', ${Date.now()})`));
       await this._evaluateInFrames(`globalThis.__pwClock.controller.resume()`);
     };
     doResume().catch(() => {
     });
   }
   async resume(progress) {
-    await this._installIfNeeded(progress);
-    this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('resume', ${Date.now()})`));
-    await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.resume()`));
+    await this._installIfNeeded();
+    this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('resume', ${Date.now()})`));
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.resume()`);
   }
-  async setFixedTime(progress, time) {
-    await this._installIfNeeded(progress);
+  async setFixedTime(time) {
+    await this._installIfNeeded();
     const timeMillis = parseTime(time);
-    this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('setFixedTime', ${Date.now()}, ${timeMillis})`));
-    await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.setFixedTime(${timeMillis})`));
+    this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('setFixedTime', ${Date.now()}, ${timeMillis})`));
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.setFixedTime(${timeMillis})`);
   }
-  async setSystemTime(progress, time) {
-    await this._installIfNeeded(progress);
+  async setSystemTime(time) {
+    await this._installIfNeeded();
     const timeMillis = parseTime(time);
-    this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('setSystemTime', ${Date.now()}, ${timeMillis})`));
-    await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.setSystemTime(${timeMillis})`));
+    this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('setSystemTime', ${Date.now()}, ${timeMillis})`));
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.setSystemTime(${timeMillis})`);
   }
-  async runFor(progress, ticks) {
-    await this._installIfNeeded(progress);
+  async runFor(ticks) {
+    await this._installIfNeeded();
     const ticksMillis = parseTicks(ticks);
-    this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('runFor', ${Date.now()}, ${ticksMillis})`));
-    await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.runFor(${ticksMillis})`));
+    this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('runFor', ${Date.now()}, ${ticksMillis})`));
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.runFor(${ticksMillis})`);
   }
-  async _installIfNeeded(progress) {
+  async _installIfNeeded() {
     if (this._initScripts.length)
       return;
     const script = `(() => {
       const module = {};
       ${rawClockSource.source}
       if (!globalThis.__pwClock)
-        globalThis.__pwClock = (module.exports.inject())(globalThis);
+        globalThis.__pwClock = (module.exports.inject())(globalThis, ${JSON.stringify(this._browserContext._browser.options.name)});
     })();`;
-    const initScript = await this._browserContext.addInitScript(progress, script);
-    await progress.race(this._evaluateInFrames(script));
+    const initScript = await this._browserContext.addInitScript(script);
+    await this._evaluateInFrames(script);
     this._initScripts.push(initScript);
   }
   async _evaluateInFrames(script) {
-    await Promise.all(this._browserContext.pages().map(async (page) => {
-      await Promise.all(page.frames().map(async (frame) => {
-        try {
-          await frame.evaluateExpression("");
-        } catch (e) {
-        }
-      }));
-    }));
     await this._browserContext.safeNonStallingEvaluateInAllFrames(script, "main", { throwOnJSErrors: true });
   }
 }

package/lib/server/console.js

@@ -22,13 +22,14 @@ __export(console_exports, {
 });
 module.exports = __toCommonJS(console_exports);
 class ConsoleMessage {
-  constructor(page, worker, type, text, args, location) {
+  constructor(page, worker, type, text, args, location, timestamp) {
     this._page = page;
     this._worker = worker;
     this._type = type;
     this._text = text;
     this._args = args;
     this._location = location || { url: "", lineNumber: 0, columnNumber: 0 };
+    this._timestamp = timestamp;
   }
   page() {
     return this._page;
@@ -50,6 +51,9 @@ class ConsoleMessage {
   location() {
     return this._location;
   }
+  timestamp() {
+    return this._timestamp;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/debugController.js

@@ -70,10 +70,12 @@ class DebugController extends import_instrumentation.SdkObject {
     await progress.race(this._closeBrowsersWithoutPages());
     this._generateAutoExpect = !!params.generateAutoExpect;
     if (params.mode === "none") {
+      const promises = [];
       for (const recorder of await progress.race(this._allRecorders())) {
-        recorder.hideHighlightedSelector();
-        recorder.setMode("none");
+        promises.push(recorder.hideHighlightedSelector());
+        promises.push(recorder.setMode("none"));
       }
+      await Promise.all(promises);
       return;
     }
     if (!this._playwright.allBrowsers().length)
@@ -97,18 +99,22 @@ class DebugController extends import_instrumentation.SdkObject {
     if (params.selector)
       (0, import_locatorParser.unsafeLocatorOrSelectorAsSelector)(this._sdkLanguage, params.selector, "data-testid");
     const ariaTemplate = params.ariaTemplate ? (0, import_ariaSnapshot.parseAriaSnapshotUnsafe)(import_utilsBundle.yaml, params.ariaTemplate) : void 0;
+    const promises = [];
     for (const recorder of await progress.race(this._allRecorders())) {
       if (ariaTemplate)
-        recorder.setHighlightedAriaTemplate(ariaTemplate);
+        promises.push(recorder.setHighlightedAriaTemplate(ariaTemplate));
       else if (params.selector)
-        recorder.setHighlightedSelector(params.selector);
+        promises.push(recorder.setHighlightedSelector(params.selector));
     }
+    await Promise.all(promises);
   }
   async hideHighlight(progress) {
+    const promises = [];
     for (const recorder of await progress.race(this._allRecorders()))
-      recorder.hideHighlightedSelector();
-    await Promise.all(this._playwright.allPages().map((p) => p.hideHighlight().catch(() => {
+      promises.push(recorder.hideHighlightedSelector());
+    promises.push(...this._playwright.allPages().map((p) => p.hideHighlight().catch(() => {
     })));
+    await Promise.all(promises);
   }
   async resume(progress) {
     for (const recorder of await progress.race(this._allRecorders()))

package/lib/server/debugger.js

@@ -21,22 +21,20 @@ __export(debugger_exports, {
   Debugger: () => Debugger
 });
 module.exports = __toCommonJS(debugger_exports);
-var import_events = require("events");
+var import_instrumentation = require("./instrumentation");
 var import_utils = require("../utils");
 var import_browserContext = require("./browserContext");
 var import_protocolMetainfo = require("../utils/isomorphic/protocolMetainfo");
 const symbol = Symbol("Debugger");
-class Debugger extends import_events.EventEmitter {
+class Debugger extends import_instrumentation.SdkObject {
   constructor(context) {
-    super();
-    this._pauseOnNextStatement = false;
-    this._pausedCallsMetadata = /* @__PURE__ */ new Map();
+    super(context, "debugger");
+    this._pauseAt = {};
+    this._enabled = false;
+    this._pauseBeforeWaitingActions = false;
     this._muted = false;
     this._context = context;
     this._context[symbol] = this;
-    this._enabled = (0, import_utils.debugMode)() === "inspector";
-    if (this._enabled)
-      this.pauseOnNextStatement();
     context.instrumentation.addListener(this, context);
     this._context.once(import_browserContext.BrowserContext.Events.Close, () => {
       this._context.instrumentation.removeListener(this);
@@ -51,67 +49,62 @@ class Debugger extends import_events.EventEmitter {
     this._muted = muted;
   }
   async onBeforeCall(sdkObject, metadata) {
-    if (this._muted)
+    if (this._muted || metadata.internal)
       return;
-    if (shouldPauseOnCall(sdkObject, metadata) || this._pauseOnNextStatement && shouldPauseBeforeStep(metadata))
-      await this.pause(sdkObject, metadata);
+    const metainfo = (0, import_protocolMetainfo.getMetainfo)(metadata);
+    const pauseOnPauseCall = this._enabled && metadata.type === "BrowserContext" && metadata.method === "pause";
+    const pauseBeforeAction = !!this._pauseAt.next && !!metainfo?.pause && (this._pauseBeforeWaitingActions || !metainfo?.isAutoWaiting);
+    const pauseOnLocation = !!this._pauseAt.location && matchesLocation(metadata, this._pauseAt.location);
+    if (pauseOnPauseCall || pauseBeforeAction || pauseOnLocation)
+      await this._pause(sdkObject, metadata);
   }
   async onBeforeInputAction(sdkObject, metadata) {
-    if (this._muted)
+    if (this._muted || metadata.internal)
       return;
-    if (this._enabled && this._pauseOnNextStatement)
-      await this.pause(sdkObject, metadata);
+    const metainfo = (0, import_protocolMetainfo.getMetainfo)(metadata);
+    const pauseBeforeInput = !!this._pauseAt.next && !!metainfo?.pause && !!metainfo?.isAutoWaiting && !this._pauseBeforeWaitingActions;
+    if (pauseBeforeInput)
+      await this._pause(sdkObject, metadata);
   }
-  async pause(sdkObject, metadata) {
-    if (this._muted)
+  async _pause(sdkObject, metadata) {
+    if (this._muted || metadata.internal)
       return;
-    this._enabled = true;
+    if (this._pausedCall)
+      return;
+    this._pauseAt = {};
     metadata.pauseStartTime = (0, import_utils.monotonicTime)();
     const result = new Promise((resolve) => {
-      this._pausedCallsMetadata.set(metadata, { resolve, sdkObject });
+      this._pausedCall = { metadata, sdkObject, resolve };
     });
     this.emit(Debugger.Events.PausedStateChanged);
     return result;
   }
-  resume(step) {
-    if (!this.isPaused())
+  resume() {
+    if (!this._pausedCall)
       return;
-    this._pauseOnNextStatement = step;
-    const endTime = (0, import_utils.monotonicTime)();
-    for (const [metadata, { resolve }] of this._pausedCallsMetadata) {
-      metadata.pauseEndTime = endTime;
-      resolve();
-    }
-    this._pausedCallsMetadata.clear();
+    this._pausedCall.metadata.pauseEndTime = (0, import_utils.monotonicTime)();
+    this._pausedCall.resolve();
+    this._pausedCall = void 0;
     this.emit(Debugger.Events.PausedStateChanged);
   }
-  pauseOnNextStatement() {
-    this._pauseOnNextStatement = true;
+  setPauseBeforeWaitingActions() {
+    this._pauseBeforeWaitingActions = true;
+  }
+  setPauseAt(at = {}) {
+    this._enabled = true;
+    this._pauseAt = at;
   }
   isPaused(metadata) {
     if (metadata)
-      return this._pausedCallsMetadata.has(metadata);
-    return !!this._pausedCallsMetadata.size;
+      return this._pausedCall?.metadata === metadata;
+    return !!this._pausedCall;
   }
   pausedDetails() {
-    const result = [];
-    for (const [metadata, { sdkObject }] of this._pausedCallsMetadata)
-      result.push({ metadata, sdkObject });
-    return result;
+    return this._pausedCall;
   }
 }
-function shouldPauseOnCall(sdkObject, metadata) {
-  if (sdkObject.attribution.playwright.options.isServer)
-    return false;
-  if (!sdkObject.attribution.browser?.options.headful && !(0, import_utils.isUnderTest)())
-    return false;
-  return metadata.method === "pause";
-}
-function shouldPauseBeforeStep(metadata) {
-  if (metadata.internal)
-    return false;
-  const metainfo = import_protocolMetainfo.methodMetainfo.get(metadata.type + "." + metadata.method);
-  return !!metainfo?.pausesBeforeAction;
+function matchesLocation(metadata, location) {
+  return !!metadata.location?.file.includes(location.file) && (location.line === void 0 || metadata.location.line === location.line) && (location.column === void 0 || metadata.location.column === location.column);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {