patchright-core 1.58.2 → 1.59.1

package/lib/server/screencast.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,171 +15,120 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var screencast_exports = {};
 __export(screencast_exports, {
   Screencast: () => Screencast
 });
 module.exports = __toCommonJS(screencast_exports);
-var import_path = __toESM(require("path"));
 var import_utils = require("../utils");
 var import_utils2 = require("../utils");
-var import_videoRecorder = require("./videoRecorder");
-var import_page = require("./page");
-var import_registry = require("./registry");
 class Screencast {
   constructor(page) {
-    this._videoRecorder = null;
-    this._videoId = null;
-    this._screencastClients = /* @__PURE__ */ new Set();
-    // Aiming at 25 fps by default - each frame is 40ms, but we give some slack with 35ms.
-    // When throttling for tracing, 200ms between frames, except for 10 frames around the action.
-    this._frameThrottler = new FrameThrottler(10, 35, 200);
-    this._frameListener = null;
-    this._page = page;
-  }
-  stopFrameThrottler() {
-    this._frameThrottler.dispose();
-  }
-  setOptions(options) {
-    this._setOptions(options).catch((e) => import_utils2.debugLogger.log("error", e));
-    this._frameThrottler.setThrottlingEnabled(!!options);
+    this._clients = /* @__PURE__ */ new Set();
+    this.page = page;
+    this.page.instrumentation.addListener(this, page.browserContext);
+  }
+  async handlePageOrContextClose() {
+    const clients = [...this._clients];
+    this._clients.clear();
+    for (const client of clients) {
+      if (client.gracefulClose)
+        await client.gracefulClose();
+    }
   }
-  throttleFrameAck(ack) {
-    this._frameThrottler.ack(ack);
+  dispose() {
+    for (const client of this._clients)
+      client.dispose();
+    this._clients.clear();
+    this.page.instrumentation.removeListener(this);
   }
-  temporarilyDisableThrottling() {
-    this._frameThrottler.recharge();
+  showActions(options) {
+    this._actions = options;
   }
-  launchVideoRecorder() {
-    const recordVideo = this._page.browserContext._options.recordVideo;
-    if (!recordVideo)
-      return void 0;
-    (0, import_utils.assert)(!this._videoId);
-    this._videoId = (0, import_utils.createGuid)();
-    const outputFile = import_path.default.join(recordVideo.dir, this._videoId + ".webm");
-    const videoOptions = {
-      // validateBrowserContextOptions ensures correct video size.
-      ...recordVideo.size,
-      outputFile
-    };
-    const ffmpegPath = import_registry.registry.findExecutable("ffmpeg").executablePathOrDie(this._page.browserContext._browser.sdkLanguage());
-    this._videoRecorder = new import_videoRecorder.VideoRecorder(ffmpegPath, videoOptions);
-    this._frameListener = import_utils.eventsHelper.addEventListener(this._page, import_page.Page.Events.ScreencastFrame, (frame) => this._videoRecorder.writeFrame(frame.buffer, frame.frameSwapWallTime / 1e3));
-    this._page.waitForInitializedOrError().then((p) => {
-      if (p instanceof Error)
-        this.stopVideoRecording().catch(() => {
-        });
-    });
-    return videoOptions;
+  hideActions() {
+    this._actions = void 0;
   }
-  async startVideoRecording(options) {
-    const videoId = this._videoId;
-    (0, import_utils.assert)(videoId);
-    this._page.once(import_page.Page.Events.Close, () => this.stopVideoRecording().catch(() => {
-    }));
-    const gotFirstFrame = new Promise((f) => this._page.once(import_page.Page.Events.ScreencastFrame, f));
-    await this._startScreencast(this._videoRecorder, {
-      quality: 90,
-      width: options.width,
-      height: options.height
-    });
-    gotFirstFrame.then(() => {
-      this._page.browserContext._browser._videoStarted(this._page.browserContext, videoId, options.outputFile, this._page.waitForInitializedOrError());
-    });
+  addClient(client) {
+    this._clients.add(client);
+    if (this._clients.size === 1)
+      this._startScreencast(client.size, client.quality);
+    return { size: this._size };
   }
-  async stopVideoRecording() {
-    if (!this._videoId)
+  removeClient(client) {
+    if (!this._clients.has(client))
       return;
-    if (this._frameListener)
-      import_utils.eventsHelper.removeEventListeners([this._frameListener]);
-    this._frameListener = null;
-    const videoId = this._videoId;
-    this._videoId = null;
-    const videoRecorder = this._videoRecorder;
-    this._videoRecorder = null;
-    await this._stopScreencast(videoRecorder);
-    await videoRecorder.stop();
-    const video = this._page.browserContext._browser._takeVideo(videoId);
-    video?.reportFinished();
-  }
-  async _setOptions(options) {
-    if (options)
-      await this._startScreencast(this, options);
-    else
-      await this._stopScreencast(this);
-  }
-  async _startScreencast(client, options) {
-    this._screencastClients.add(client);
-    if (this._screencastClients.size === 1) {
-      await this._page.delegate.startScreencast({
-        width: options.width,
-        height: options.height,
-        quality: options.quality
-      });
+    this._clients.delete(client);
+    if (!this._clients.size)
+      this._stopScreencast();
+  }
+  size() {
+    return this._size;
+  }
+  _startScreencast(size, quality) {
+    this._size = size;
+    if (!this._size) {
+      const viewport = this.page.browserContext._options.viewport || { width: 800, height: 600 };
+      const scale = Math.min(1, 800 / Math.max(viewport.width, viewport.height));
+      this._size = {
+        width: Math.floor(viewport.width * scale),
+        height: Math.floor(viewport.height * scale)
+      };
     }
+    this._size = {
+      width: this._size.width & ~1,
+      height: this._size.height & ~1
+    };
+    this.page.delegate.startScreencast({
+      width: this._size.width,
+      height: this._size.height,
+      quality: quality ?? 90
+    });
   }
-  async _stopScreencast(client) {
-    this._screencastClients.delete(client);
-    if (!this._screencastClients.size)
-      await this._page.delegate.stopScreencast();
-  }
-}
-class FrameThrottler {
-  constructor(nonThrottledFrames, defaultInterval, throttlingInterval) {
-    this._acks = [];
-    this._throttlingEnabled = false;
-    this._nonThrottledFrames = nonThrottledFrames;
-    this._budget = nonThrottledFrames;
-    this._defaultInterval = defaultInterval;
-    this._throttlingInterval = throttlingInterval;
-    this._tick();
+  _stopScreencast() {
+    this.page.delegate.stopScreencast();
   }
-  dispose() {
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId);
-      this._timeoutId = void 0;
+  onScreencastFrame(frame, ack) {
+    const asyncResults = [];
+    for (const client of this._clients) {
+      const result = client.onFrame(frame);
+      if (result)
+        asyncResults.push(result);
     }
-  }
-  setThrottlingEnabled(enabled) {
-    this._throttlingEnabled = enabled;
-  }
-  recharge() {
-    for (const ack of this._acks)
-      ack();
-    this._acks = [];
-    this._budget = this._nonThrottledFrames;
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId);
-      this._tick();
+    if (ack) {
+      if (!asyncResults.length)
+        ack();
+      else
+        Promise.race(asyncResults).then(ack);
     }
   }
-  ack(ack) {
-    if (!this._timeoutId) {
-      ack();
+  async onBeforeCall(sdkObject, metadata, parentId) {
+    if (!this._actions)
       return;
-    }
-    this._acks.push(ack);
+    metadata.annotate = true;
   }
-  _tick() {
-    const ack = this._acks.shift();
-    if (ack) {
-      --this._budget;
-      ack();
-    }
-    if (this._throttlingEnabled && this._budget <= 0) {
-      this._timeoutId = setTimeout(() => this._tick(), this._throttlingInterval);
-    } else {
-      this._timeoutId = setTimeout(() => this._tick(), this._defaultInterval);
-    }
+  async onBeforeInputAction(sdkObject, metadata) {
+    if (!this._actions)
+      return;
+    const page = sdkObject.attribution.page;
+    if (!page)
+      return;
+    const actionTitle = (0, import_utils.renderTitleForCall)(metadata);
+    const utility = await page.mainFrame()._utilityContext();
+    await utility.evaluate(async (options) => {
+      const { injected, duration } = options;
+      injected.setScreencastAnnotation(options);
+      await new Promise((f) => injected.utils.builtins.setTimeout(f, duration));
+      injected.setScreencastAnnotation(null);
+    }, {
+      injected: await utility.injectedScript(),
+      duration: this._actions?.duration ?? 500,
+      point: metadata.point,
+      box: metadata.box,
+      actionTitle,
+      position: this._actions?.position,
+      fontSize: this._actions?.fontSize
+    }).catch((e) => import_utils2.debugLogger.log("error", e));
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/screenshotter.js

@@ -213,12 +213,6 @@ class Screenshotter {
     if (disableAnimations)
       progress.log("  disabled all CSS animations");
     const syncAnimations = this._page.delegate.shouldToggleStyleSheetToSyncAnimations();
-    await Promise.all(this._page.frames().map(async (f) => {
-      try {
-        await f._utilityContext();
-      } catch {
-      }
-    }));
     await progress.race(this._page.safeNonStallingEvaluateInAllFrames("(" + inPagePrepareForScreenshots.toString() + `)(${JSON.stringify(screenshotStyle)}, ${hideCaret}, ${disableAnimations}, ${syncAnimations})`, "utility"));
     try {
       if (!process.env.PW_TEST_SCREENSHOT_NO_FONTS_READY) {

package/lib/server/trace/recorder/snapshotter.js

@@ -49,7 +49,7 @@ class Snapshotter {
   }
   async reset() {
     if (this._started)
-      await this._context.safeNonStallingEvaluateInAllFrames(`window["${this._snapshotStreamer}"].reset()`, "utility");
+      await this._context.safeNonStallingEvaluateInAllFrames(`window["${this._snapshotStreamer}"].reset()`, "main");
   }
   stop() {
     this._started = false;
@@ -57,20 +57,20 @@ class Snapshotter {
   async resetForReuse() {
     if (this._initScript) {
       import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
+      await this._initScript.dispose();
       this._initScript = void 0;
-      this._initScriptSource = void 0;
     }
   }
   async _initialize() {
-    const { javaScriptEnabled } = this._context._options;
-    this._initScriptSource = `(${import_snapshotterInjected.frameSnapshotStreamer})("${this._snapshotStreamer}", ${javaScriptEnabled || javaScriptEnabled === void 0})`;
-    this._initScript = true;
     for (const page of this._context.pages())
       this._onPage(page);
     this._eventListeners = [
       import_eventsHelper.eventsHelper.addEventListener(this._context, import_browserContext.BrowserContext.Events.Page, this._onPage.bind(this))
     ];
-    await this._context.safeNonStallingEvaluateInAllFrames(this._initScriptSource, "utility");
+    const { javaScriptEnabled } = this._context._options;
+    const initScriptSource = `(${import_snapshotterInjected.frameSnapshotStreamer})("${this._snapshotStreamer}", ${javaScriptEnabled || javaScriptEnabled === void 0})`;
+    this._initScript = await this._context.addInitScript(initScriptSource);
+    await this._context.safeNonStallingEvaluateInAllFrames(initScriptSource, "main");
   }
   dispose() {
     import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
@@ -80,7 +80,7 @@ class Snapshotter {
     frame[kNeedsResetSymbol] = false;
     const expression = `window["${this._snapshotStreamer}"].captureSnapshot(${needsReset ? "true" : "false"})`;
     try {
-      return await frame.nonStallingEvaluateInExistingContext(expression, "utility");
+      return await frame.nonStallingRawEvaluateInExistingMainContext(expression);
     } catch (e) {
       frame[kNeedsResetSymbol] = true;
       import_debugLogger.debugLogger.log("error", e);
@@ -124,7 +124,6 @@ class Snapshotter {
     for (const frame of page.frames())
       this._annotateFrameHierarchy(frame);
     this._eventListeners.push(import_eventsHelper.eventsHelper.addEventListener(page, import_page.Page.Events.FrameAttached, (frame) => this._annotateFrameHierarchy(frame)));
-    this._eventListeners.push(import_eventsHelper.eventsHelper.addEventListener(page, import_page.Page.Events.InternalFrameNavigatedToNewDocument, (frame) => this._onFrameNavigated(frame)));
   }
   async _annotateFrameHierarchy(frame) {
     try {
@@ -132,7 +131,7 @@ class Snapshotter {
       const parent = frame.parentFrame();
       if (!parent)
         return;
-      const context = await parent._utilityContext();
+      const context = await parent._mainContext();
       await context?.evaluate(({ snapshotStreamer, frameElement: frameElement2, frameId }) => {
         window[snapshotStreamer].markIframe(frameElement2, frameId);
       }, { snapshotStreamer: this._snapshotStreamer, frameElement, frameId: frame.guid });
@@ -140,14 +139,6 @@ class Snapshotter {
     } catch (e) {
     }
   }
-  async _onFrameNavigated(frame) {
-    if (!this._initScriptSource)
-      return;
-    try {
-      await frame.nonStallingEvaluateInExistingContext(this._initScriptSource, "utility");
-    } catch (e) {
-    }
-  }
 }
 const kNeedsResetSymbol = Symbol("kNeedsReset");
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/trace/recorder/snapshotterInjected.js

@@ -60,11 +60,28 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
   class Streamer {
     constructor() {
       this._lastSnapshotNumber = 0;
+      this._staleStyleSheets = /* @__PURE__ */ new Set();
       this._modifiedStyleSheets = /* @__PURE__ */ new Set();
+      this._readingStyleSheet = false;
+      const invalidateCSSGroupingRule = (rule) => {
+        if (rule.parentStyleSheet)
+          this._invalidateStyleSheet(rule.parentStyleSheet);
+      };
+      this._interceptNativeMethod(window.CSSStyleSheet.prototype, "insertRule", (sheet) => this._invalidateStyleSheet(sheet));
+      this._interceptNativeMethod(window.CSSStyleSheet.prototype, "deleteRule", (sheet) => this._invalidateStyleSheet(sheet));
+      this._interceptNativeMethod(window.CSSStyleSheet.prototype, "addRule", (sheet) => this._invalidateStyleSheet(sheet));
+      this._interceptNativeMethod(window.CSSStyleSheet.prototype, "removeRule", (sheet) => this._invalidateStyleSheet(sheet));
+      this._interceptNativeGetter(window.CSSStyleSheet.prototype, "rules", (sheet) => this._invalidateStyleSheet(sheet));
+      this._interceptNativeGetter(window.CSSStyleSheet.prototype, "cssRules", (sheet) => this._invalidateStyleSheet(sheet));
+      this._interceptNativeMethod(window.CSSStyleSheet.prototype, "replaceSync", (sheet) => this._invalidateStyleSheet(sheet));
+      this._interceptNativeMethod(window.CSSGroupingRule.prototype, "insertRule", invalidateCSSGroupingRule);
+      this._interceptNativeMethod(window.CSSGroupingRule.prototype, "deleteRule", invalidateCSSGroupingRule);
+      this._interceptNativeGetter(window.CSSGroupingRule.prototype, "cssRules", invalidateCSSGroupingRule);
       this._interceptNativeSetter(window.StyleSheet.prototype, "disabled", (sheet) => {
         if (sheet instanceof CSSStyleSheet)
           this._invalidateStyleSheet(sheet);
       });
+      this._interceptNativeAsyncMethod(window.CSSStyleSheet.prototype, "replace", (sheet) => this._invalidateStyleSheet(sheet));
       this._fakeBase = document.createElement("base");
       this._observer = new MutationObserver((list) => this._handleMutations(list));
       const observerConfig = { attributes: true, subtree: true };
@@ -105,6 +122,37 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
           delete event.composedPath()[0].__playwright_target__;
       });
     }
+    _interceptNativeMethod(obj, method, cb) {
+      const native = obj[method];
+      if (!native)
+        return;
+      obj[method] = function(...args) {
+        const result = native.call(this, ...args);
+        cb(this, result);
+        return result;
+      };
+    }
+    _interceptNativeAsyncMethod(obj, method, cb) {
+      const native = obj[method];
+      if (!native)
+        return;
+      obj[method] = async function(...args) {
+        const result = await native.call(this, ...args);
+        cb(this, result);
+        return result;
+      };
+    }
+    _interceptNativeGetter(obj, prop, cb) {
+      const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+      Object.defineProperty(obj, prop, {
+        ...descriptor,
+        get: function() {
+          const result = descriptor.get.call(this);
+          cb(this, result);
+          return result;
+        }
+      });
+    }
     _interceptNativeSetter(obj, prop, cb) {
       const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
       Object.defineProperty(obj, prop, {
@@ -120,37 +168,44 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
       for (const mutation of list)
         ensureCachedData(mutation.target).attributesCached = void 0;
     }
+    _invalidateStyleSheet(sheet) {
+      if (this._readingStyleSheet)
+        return;
+      this._staleStyleSheets.add(sheet);
+      if (sheet.href !== null)
+        this._modifiedStyleSheets.add(sheet);
+    }
     _updateStyleElementStyleSheetTextIfNeeded(sheet, forceText) {
       const data = ensureCachedData(sheet);
-      try {
-        data.cssText = this._getSheetText(sheet);
-      } catch (e) {
-        data.cssText = "";
+      if (this._staleStyleSheets.has(sheet) || forceText && data.cssText === void 0) {
+        this._staleStyleSheets.delete(sheet);
+        try {
+          data.cssText = this._getSheetText(sheet);
+        } catch (e) {
+          data.cssText = "";
+        }
       }
       return data.cssText;
     }
     // Returns either content, ref, or no override.
     _updateLinkStyleSheetTextIfNeeded(sheet, snapshotNumber) {
       const data = ensureCachedData(sheet);
-      try {
-        const currentText = this._getSheetText(sheet);
-        if (data.cssText === void 0) {
-          data.cssText = currentText;
-          return void 0;
+      if (this._staleStyleSheets.has(sheet)) {
+        this._staleStyleSheets.delete(sheet);
+        try {
+          data.cssText = this._getSheetText(sheet);
+          data.cssRef = snapshotNumber;
+          return data.cssText;
+        } catch (e) {
         }
-        if (currentText === data.cssText)
-          return data.cssRef === void 0 ? void 0 : snapshotNumber - data.cssRef;
-        data.cssText = currentText;
-        data.cssRef = snapshotNumber;
-        return data.cssText;
-      } catch (e) {
-        return void 0;
       }
+      return data.cssRef === void 0 ? void 0 : snapshotNumber - data.cssRef;
     }
     markIframe(iframeElement, frameId) {
       iframeElement[kSnapshotFrameId] = frameId;
     }
     reset() {
+      this._staleStyleSheets.clear();
       const visitNode = (node) => {
         resetCachedData(node);
         if (node.nodeType === Node.ELEMENT_NODE) {
@@ -209,10 +264,17 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
       return document.baseURI;
     }
     _getSheetText(sheet) {
-      const rules = [];
-      for (const rule of sheet.cssRules)
-        rules.push(rule.cssText);
-      return rules.join("\n");
+      this._readingStyleSheet = true;
+      try {
+        if (sheet.disabled)
+          return "";
+        const rules = [];
+        for (const rule of sheet.cssRules)
+          rules.push(rule.cssText);
+        return rules.join("\n");
+      } finally {
+        this._readingStyleSheet = false;
+      }
     }
     captureSnapshot(needsReset) {
       const timestamp = performance.now();