@smoothdeploy/playwright-core 1.57.1 → 1.58.1-beta-1770452953000

package/lib/server/chromium/crNetworkManager.js

@@ -296,6 +296,10 @@ class CRNetworkManager {
     if (requestPausedEvent) {
       if (redirectedFrom || !this._userRequestInterceptionEnabled && this._protocolRequestInterceptionEnabled) {
         headersOverride = redirectedFrom?._originalRequestRoute?._alreadyContinuedParams?.headers;
+        if (headersOverride) {
+          const originalHeaders = Object.entries(requestPausedEvent.request.headers).map(([name, value]) => ({ name, value }));
+          headersOverride = network.applyHeadersOverrides(originalHeaders, headersOverride);
+        }
         requestPausedSessionInfo.session._sendMayFail("Fetch.continueRequest", { requestId: requestPausedEvent.requestId, headers: headersOverride });
       } else {
         route = new RouteImpl(requestPausedSessionInfo.session, requestPausedEvent.requestId);
@@ -482,12 +486,11 @@ class InterceptableRequest {
       url,
       postDataEntries = null
     } = requestPausedEvent ? requestPausedEvent.request : requestWillBeSentEvent.request;
-    const type = (requestWillBeSentEvent.type || "").toLowerCase();
     let postDataBuffer = null;
     const entries = postDataEntries?.filter((entry) => entry.bytes);
     if (entries && entries.length)
       postDataBuffer = Buffer.concat(entries.map((entry) => Buffer.from(entry.bytes, "base64")));
-    this.request = new network.Request(context, frame, serviceWorker, redirectedFrom?.request || null, documentId, url, type, method, postDataBuffer, headersOverride || (0, import_utils.headersObjectToArray)(headers));
+    this.request = new network.Request(context, frame, serviceWorker, redirectedFrom?.request || null, documentId, url, toResourceType(requestWillBeSentEvent.type || "Other"), method, postDataBuffer, headersOverride || (0, import_utils.headersObjectToArray)(headers));
   }
 }
 class RouteImpl {
@@ -660,6 +663,44 @@ class ResponseExtraInfoTracker {
     this._requests.delete(requestId);
   }
 }
+function toResourceType(type) {
+  switch (type) {
+    case "Document":
+      return "document";
+    case "Stylesheet":
+      return "stylesheet";
+    case "Image":
+      return "image";
+    case "Media":
+      return "media";
+    case "Font":
+      return "font";
+    case "Script":
+      return "script";
+    case "TextTrack":
+      return "texttrack";
+    case "XHR":
+      return "xhr";
+    case "Fetch":
+      return "fetch";
+    case "EventSource":
+      return "eventsource";
+    case "WebSocket":
+      return "websocket";
+    case "Manifest":
+      return "manifest";
+    case "Ping":
+      return "ping";
+    case "CSPViolationReport":
+      return "cspreport";
+    case "Prefetch":
+    case "SignedExchange":
+    case "Preflight":
+    case "FedCM":
+    default:
+      return "other";
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CRNetworkManager

package/lib/server/chromium/crPage.js

@@ -31,9 +31,7 @@ __export(crPage_exports, {
   CRPage: () => CRPage
 });
 module.exports = __toCommonJS(crPage_exports);
-var import_path = __toESM(require("path"));
 var import_assert = require("../../utils/isomorphic/assert");
-var import_crypto = require("../utils/crypto");
 var import_eventsHelper = require("../utils/eventsHelper");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
 var dialog = __toESM(require("../dialog"));
@@ -42,7 +40,6 @@ var frames = __toESM(require("../frames"));
 var import_helper = require("../helper");
 var network = __toESM(require("../network"));
 var import_page = require("../page");
-var import_registry = require("../registry");
 var import_crCoverage = require("./crCoverage");
 var import_crDragDrop = require("./crDragDrop");
 var import_crExecutionContext = require("./crExecutionContext");
@@ -51,7 +48,6 @@ var import_crNetworkManager = require("./crNetworkManager");
 var import_crPdf = require("./crPdf");
 var import_crProtocolHelper = require("./crProtocolHelper");
 var import_defaultFontFamilies = require("./defaultFontFamilies");
-var import_videoRecorder = require("./videoRecorder");
 var import_errors = require("../errors");
 var import_protocolError = require("../protocolError");
 class CRPage {
@@ -236,17 +232,16 @@ class CRPage {
   async scrollRectIntoViewIfNeeded(handle, rect) {
     return this._sessionForHandle(handle)._scrollRectIntoViewIfNeeded(handle, rect);
   }
-  async setScreencastOptions(options) {
-    if (options) {
-      await this._mainFrameSession._startScreencast(this, {
-        format: "jpeg",
-        quality: options.quality,
-        maxWidth: options.width,
-        maxHeight: options.height
-      });
-    } else {
-      await this._mainFrameSession._stopScreencast(this);
-    }
+  async startScreencast(options) {
+    await this._mainFrameSession._client.send("Page.startScreencast", {
+      format: "jpeg",
+      quality: options.quality,
+      maxWidth: options.width,
+      maxHeight: options.height
+    });
+  }
+  async stopScreencast() {
+    await this._mainFrameSession._client._sendMayFail("Page.stopScreencast");
   }
   rafCountForStablePosition() {
     return 1;
@@ -311,9 +306,6 @@ class FrameSession {
     // Marks the oopif session that remote -> local transition has happened in the parent.
     // See Target.detachedFromTarget handler for details.
     this._swappedIn = false;
-    this._videoRecorder = null;
-    this._screencastId = null;
-    this._screencastClients = /* @__PURE__ */ new Set();
     this._workerSessions = /* @__PURE__ */ new Map();
     this._initScriptIds = /* @__PURE__ */ new Map();
     this._client = client;
@@ -365,23 +357,9 @@ class FrameSession {
       const { windowId } = await this._client.send("Browser.getWindowForTarget");
       this._windowId = windowId;
     }
-    let screencastOptions;
-    if (!this._page.isStorageStatePage && this._isMainFrame() && this._crPage._browserContext._options.recordVideo && hasUIWindow) {
-      const screencastId = (0, import_crypto.createGuid)();
-      const outputFile = import_path.default.join(this._crPage._browserContext._options.recordVideo.dir, screencastId + ".webm");
-      screencastOptions = {
-        // validateBrowserContextOptions ensures correct video size.
-        ...this._crPage._browserContext._options.recordVideo.size,
-        outputFile
-      };
-      await this._crPage._browserContext._ensureVideosPath();
-      await this._createVideoRecorder(screencastId, screencastOptions);
-      this._crPage._page.waitForInitializedOrError().then((p) => {
-        if (p instanceof Error)
-          this._stopVideoRecording().catch(() => {
-          });
-      });
-    }
+    let videoOptions;
+    if (!this._page.isStorageStatePage && this._isMainFrame() && hasUIWindow)
+      videoOptions = this._crPage._page.screencast.launchVideoRecorder();
     let lifecycleEventsEnabled;
     if (!this._isMainFrame())
       this._addRendererListeners();
@@ -461,15 +439,15 @@ class FrameSession {
           true
           /* runImmediately */
         ));
-      if (screencastOptions)
-        promises.push(this._startVideoRecording(screencastOptions));
+      if (videoOptions)
+        promises.push(this._crPage._page.screencast.startVideoRecording(videoOptions));
     }
     promises.push(this._client.send("Runtime.runIfWaitingForDebugger"));
     promises.push(this._firstNonInitialNavigationCommittedPromise);
     await Promise.all(promises);
   }
   dispose() {
-    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError());
+    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError(this._page.closeReason()));
     for (const childSession of this._childSessions)
       childSession.dispose();
     if (this._parentSession)
@@ -730,63 +708,17 @@ class FrameSession {
     }
   }
   _onScreencastFrame(payload) {
-    this._page.throttleScreencastFrameAck(() => {
-      this._client.send("Page.screencastFrameAck", { sessionId: payload.sessionId }).catch(() => {
-      });
+    this._page.screencast.throttleFrameAck(() => {
+      this._client._sendMayFail("Page.screencastFrameAck", { sessionId: payload.sessionId });
     });
     const buffer = Buffer.from(payload.data, "base64");
     this._page.emit(import_page.Page.Events.ScreencastFrame, {
       buffer,
-      frameSwapWallTime: payload.metadata.timestamp ? payload.metadata.timestamp * 1e3 : void 0,
+      frameSwapWallTime: payload.metadata.timestamp ? payload.metadata.timestamp * 1e3 : Date.now(),
       width: payload.metadata.deviceWidth,
       height: payload.metadata.deviceHeight
     });
   }
-  async _createVideoRecorder(screencastId, options) {
-    (0, import_assert.assert)(!this._screencastId);
-    const ffmpegPath = import_registry.registry.findExecutable("ffmpeg").executablePathOrDie(this._page.browserContext._browser.sdkLanguage());
-    this._videoRecorder = await import_videoRecorder.VideoRecorder.launch(this._crPage._page, ffmpegPath, options);
-    this._screencastId = screencastId;
-  }
-  async _startVideoRecording(options) {
-    const screencastId = this._screencastId;
-    (0, import_assert.assert)(screencastId);
-    this._page.once(import_page.Page.Events.Close, () => this._stopVideoRecording().catch(() => {
-    }));
-    const gotFirstFrame = new Promise((f) => this._client.once("Page.screencastFrame", f));
-    await this._startScreencast(this._videoRecorder, {
-      format: "jpeg",
-      quality: 90,
-      maxWidth: options.width,
-      maxHeight: options.height
-    });
-    gotFirstFrame.then(() => {
-      this._crPage._browserContext._browser._videoStarted(this._crPage._browserContext, screencastId, options.outputFile, this._crPage._page.waitForInitializedOrError());
-    });
-  }
-  async _stopVideoRecording() {
-    if (!this._screencastId)
-      return;
-    const screencastId = this._screencastId;
-    this._screencastId = null;
-    const recorder = this._videoRecorder;
-    this._videoRecorder = null;
-    await this._stopScreencast(recorder);
-    await recorder.stop().catch(() => {
-    });
-    const video = this._crPage._browserContext._browser._takeVideo(screencastId);
-    video?.reportFinished();
-  }
-  async _startScreencast(client, options = {}) {
-    this._screencastClients.add(client);
-    if (this._screencastClients.size === 1)
-      await this._client.send("Page.startScreencast", options);
-  }
-  async _stopScreencast(client) {
-    this._screencastClients.delete(client);
-    if (!this._screencastClients.size)
-      await this._client._sendMayFail("Page.stopScreencast");
-  }
   async _updateGeolocation(initial) {
     const geolocation = this._crPage._browserContext._options.geolocation;
     if (!initial || geolocation)

package/lib/server/codegen/javascript.js

@@ -90,7 +90,7 @@ class JavaScriptLanguageGenerator {
       case "fill":
         return `await ${subject}.${this._asLocator(action.selector)}.fill(${quote(action.text)});`;
       case "setInputFiles":
-        return `await ${subject}.${this._asLocator(action.selector)}.setInputFiles(${formatObject(action.files.length === 1 ? action.files[0] : action.files)});`;
+        return `await ${subject}.${this._asLocator(action.selector)}.setInputFiles(${(0, import_utils.formatObject)(action.files.length === 1 ? action.files[0] : action.files)});`;
       case "press": {
         const modifiers = (0, import_language.toKeyboardModifiers)(action.modifiers);
         const shortcut = [...modifiers, action.key].join("+");
@@ -99,7 +99,7 @@ class JavaScriptLanguageGenerator {
       case "navigate":
         return `await ${subject}.goto(${quote(action.url)});`;
       case "select":
-        return `await ${subject}.${this._asLocator(action.selector)}.selectOption(${formatObject(action.options.length === 1 ? action.options[0] : action.options)});`;
+        return `await ${subject}.${this._asLocator(action.selector)}.selectOption(${(0, import_utils.formatObject)(action.options.length === 1 ? action.options[0] : action.options)});`;
       case "assertText":
         return `${this._isTest ? "" : "// "}await expect(${subject}.${this._asLocator(action.selector)}).${action.substring ? "toContainText" : "toHaveText"}(${quote(action.text)});`;
       case "assertChecked":
@@ -151,7 +151,7 @@ ${useText ? "\ntest.use(" + useText + ");\n" : ""}
       const { ${options.browserName}${options.deviceName ? ", devices" : ""} } = require('playwright');
 
       (async () => {
-        const browser = await ${options.browserName}.launch(${formatObjectOrVoid(options.launchOptions)});
+        const browser = await ${options.browserName}.launch(${(0, import_utils.formatObjectOrVoid)(options.launchOptions)});
         const context = await browser.newContext(${formatContextOptions(options.contextOptions, options.deviceName, false)});`);
     if (options.contextOptions.recordHar)
       formatter.add(`        await context.routeFromHAR(${quote(options.contextOptions.recordHar.path)});`);
@@ -171,37 +171,14 @@ function formatOptions(value, hasArguments) {
   const keys = Object.keys(value).filter((key) => value[key] !== void 0);
   if (!keys.length)
     return "";
-  return (hasArguments ? ", " : "") + formatObject(value);
-}
-function formatObject(value, indent = "  ") {
-  if (typeof value === "string")
-    return quote(value);
-  if (Array.isArray(value))
-    return `[${value.map((o) => formatObject(o)).join(", ")}]`;
-  if (typeof value === "object") {
-    const keys = Object.keys(value).filter((key) => value[key] !== void 0).sort();
-    if (!keys.length)
-      return "{}";
-    const tokens = [];
-    for (const key of keys)
-      tokens.push(`${key}: ${formatObject(value[key])}`);
-    return `{
-${indent}${tokens.join(`,
-${indent}`)}
-}`;
-  }
-  return String(value);
-}
-function formatObjectOrVoid(value, indent = "  ") {
-  const result = formatObject(value, indent);
-  return result === "{}" ? "" : result;
+  return (hasArguments ? ", " : "") + (0, import_utils.formatObject)(value);
 }
 function formatContextOptions(options, deviceName, isTest) {
   const device = deviceName && import_deviceDescriptors.deviceDescriptors[deviceName];
   options = { ...options, recordHar: void 0 };
   if (!device)
-    return formatObjectOrVoid(options);
-  let serializedObject = formatObjectOrVoid((0, import_language.sanitizeDeviceOptions)(device, options));
+    return (0, import_utils.formatObjectOrVoid)(options);
+  let serializedObject = (0, import_utils.formatObjectOrVoid)((0, import_language.sanitizeDeviceOptions)(device, options));
   if (!serializedObject)
     serializedObject = "{\n}";
   const lines = serializedObject.split("\n");