@checkly/playwright-core 1.51.17-beta.1 → 1.54.2-beta.0

package/lib/server/bidi/bidiBrowser.js

@@ -1,67 +1,91 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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 bidiBrowser_exports = {};
+__export(bidiBrowser_exports, {
+  BidiBrowser: () => BidiBrowser,
+  BidiBrowserContext: () => BidiBrowserContext,
+  Network: () => Network
 });
-exports.Network = exports.BidiBrowserContext = exports.BidiBrowser = void 0;
-var _eventsHelper = require("../utils/eventsHelper");
-var _browser = require("../browser");
-var _browserContext = require("../browserContext");
-var network = _interopRequireWildcard(require("../network"));
-var _bidiConnection = require("./bidiConnection");
-var _bidiNetworkManager = require("./bidiNetworkManager");
-var _bidiPage = require("./bidiPage");
-var bidi = _interopRequireWildcard(require("./third_party/bidiProtocol"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the 'License');
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an 'AS IS' BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-class BidiBrowser extends _browser.Browser {
+module.exports = __toCommonJS(bidiBrowser_exports);
+var import_eventsHelper = require("../utils/eventsHelper");
+var import_browser = require("../browser");
+var import_browserContext = require("../browserContext");
+var network = __toESM(require("../network"));
+var import_bidiConnection = require("./bidiConnection");
+var import_bidiNetworkManager = require("./bidiNetworkManager");
+var import_bidiPage = require("./bidiPage");
+var import_page = require("../page");
+var bidi = __toESM(require("./third_party/bidiProtocol"));
+class BidiBrowser extends import_browser.Browser {
+  constructor(parent, transport, options) {
+    super(parent, options);
+    this._contexts = /* @__PURE__ */ new Map();
+    this._bidiPages = /* @__PURE__ */ new Map();
+    this._connection = new import_bidiConnection.BidiConnection(transport, this._onDisconnect.bind(this), options.protocolLogger, options.browserLogsCollector);
+    this._browserSession = this._connection.browserSession;
+    this._eventListeners = [
+      import_eventsHelper.eventsHelper.addEventListener(this._browserSession, "browsingContext.contextCreated", this._onBrowsingContextCreated.bind(this)),
+      import_eventsHelper.eventsHelper.addEventListener(this._browserSession, "script.realmDestroyed", this._onScriptRealmDestroyed.bind(this))
+    ];
+  }
   static async connect(parent, transport, options) {
     const browser = new BidiBrowser(parent, transport, options);
-    if (options.__testHookOnConnectToBrowser) await options.__testHookOnConnectToBrowser();
+    if (options.__testHookOnConnectToBrowser)
+      await options.__testHookOnConnectToBrowser();
     let proxy;
     if (options.proxy) {
       proxy = {
-        proxyType: 'manual'
+        proxyType: "manual"
       };
-      const url = new URL(options.proxy.server); // Validate proxy server.
+      const url = new URL(options.proxy.server);
       switch (url.protocol) {
-        case 'http:':
+        case "http:":
           proxy.httpProxy = url.host;
           break;
-        case 'https:':
+        case "https:":
           proxy.httpsProxy = url.host;
           break;
-        case 'socks4:':
+        case "socks4:":
           proxy.socksProxy = url.host;
           proxy.socksVersion = 4;
           break;
-        case 'socks5:':
+        case "socks5:":
           proxy.socksProxy = url.host;
           proxy.socksVersion = 5;
           break;
         default:
-          throw new Error('Invalid proxy server protocol: ' + options.proxy.server);
+          throw new Error("Invalid proxy server protocol: " + options.proxy.server);
       }
-      if (options.proxy.bypass) proxy.noProxy = options.proxy.bypass.split(',');
-      // TODO: support authentication.
+      if (options.proxy.bypass)
+        proxy.noProxy = options.proxy.bypass.split(",");
     }
-    browser._bidiSessionInfo = await browser._browserSession.send('session.new', {
+    browser._bidiSessionInfo = await browser._browserSession.send("session.new", {
       capabilities: {
         alwaysMatch: {
           acceptInsecureCerts: false,
@@ -73,37 +97,30 @@ class BidiBrowser extends _browser.Browser {
         }
       }
     });
-    await browser._browserSession.send('session.subscribe', {
-      events: ['browsingContext', 'network', 'log', 'script']
+    await browser._browserSession.send("session.subscribe", {
+      events: [
+        "browsingContext",
+        "network",
+        "log",
+        "script"
+      ]
     });
     if (options.persistent) {
-      browser._defaultContext = new BidiBrowserContext(browser, undefined, options.persistent);
-      await browser._defaultContext._initialize();
-      // Create default page as we cannot get access to the existing one.
+      const context = new BidiBrowserContext(browser, void 0, options.persistent);
+      browser._defaultContext = context;
+      await context._initialize();
       const page = await browser._defaultContext.doCreateNewPage();
       await page.waitForInitializedOrError();
     }
     return browser;
   }
-  constructor(parent, transport, options) {
-    super(parent, options);
-    this._connection = void 0;
-    this._browserSession = void 0;
-    this._bidiSessionInfo = void 0;
-    this._contexts = new Map();
-    this._bidiPages = new Map();
-    this._eventListeners = void 0;
-    this._connection = new _bidiConnection.BidiConnection(transport, this._onDisconnect.bind(this), options.protocolLogger, options.browserLogsCollector);
-    this._browserSession = this._connection.browserSession;
-    this._eventListeners = [_eventsHelper.eventsHelper.addEventListener(this._browserSession, 'browsingContext.contextCreated', this._onBrowsingContextCreated.bind(this)), _eventsHelper.eventsHelper.addEventListener(this._browserSession, 'script.realmDestroyed', this._onScriptRealmDestroyed.bind(this))];
-  }
   _onDisconnect() {
     this._didClose();
   }
   async doCreateNewContext(options) {
-    const {
-      userContext
-    } = await this._browserSession.send('browser.createUserContext', {});
+    const { userContext } = await this._browserSession.send("browser.createUserContext", {
+      acceptInsecureCerts: options.ignoreHTTPSErrors
+    });
     const context = new BidiBrowserContext(this, userContext, options);
     await context._initialize();
     this._contexts.set(userContext, context);
@@ -124,23 +141,27 @@ class BidiBrowser extends _browser.Browser {
   _onBrowsingContextCreated(event) {
     if (event.parent) {
       const parentFrameId = event.parent;
-      for (const page of this._bidiPages.values()) {
-        const parentFrame = page._page._frameManager.frame(parentFrameId);
-        if (!parentFrame) continue;
-        page._session.addFrameBrowsingContext(event.context);
-        page._page._frameManager.frameAttached(event.context, parentFrameId);
-        const frame = page._page._frameManager.frame(event.context);
-        if (frame) frame._url = event.url;
+      for (const page2 of this._bidiPages.values()) {
+        const parentFrame = page2._page.frameManager.frame(parentFrameId);
+        if (!parentFrame)
+          continue;
+        page2._session.addFrameBrowsingContext(event.context);
+        page2._page.frameManager.frameAttached(event.context, parentFrameId);
+        const frame = page2._page.frameManager.frame(event.context);
+        if (frame)
+          frame._url = event.url;
         return;
       }
       return;
     }
     let context = this._contexts.get(event.userContext);
-    if (!context) context = this._defaultContext;
-    if (!context) return;
+    if (!context)
+      context = this._defaultContext;
+    if (!context)
+      return;
     const session = this._connection.createMainFrameBrowsingContextSession(event.context);
     const opener = event.originalOpener && this._bidiPages.get(event.originalOpener);
-    const page = new _bidiPage.BidiPage(context, session, opener || null);
+    const page = new import_bidiPage.BidiPage(context, session, opener || null);
     page._page.mainFrame()._url = event.url;
     this._bidiPages.set(event.context, page);
   }
@@ -149,166 +170,284 @@ class BidiBrowser extends _browser.Browser {
       this._browserSession.removeFrameBrowsingContext(event.context);
       const parentFrameId = event.parent;
       for (const page of this._bidiPages.values()) {
-        const parentFrame = page._page._frameManager.frame(parentFrameId);
-        if (!parentFrame) continue;
-        page._page._frameManager.frameDetached(event.context);
+        const parentFrame = page._page.frameManager.frame(parentFrameId);
+        if (!parentFrame)
+          continue;
+        page._page.frameManager.frameDetached(event.context);
         return;
       }
       return;
     }
     const bidiPage = this._bidiPages.get(event.context);
-    if (!bidiPage) return;
+    if (!bidiPage)
+      return;
     bidiPage.didClose();
     this._bidiPages.delete(event.context);
   }
   _onScriptRealmDestroyed(event) {
     for (const page of this._bidiPages.values()) {
-      if (page._onRealmDestroyed(event)) return;
+      if (page._onRealmDestroyed(event))
+        return;
     }
   }
 }
-exports.BidiBrowser = BidiBrowser;
-class BidiBrowserContext extends _browserContext.BrowserContext {
+class BidiBrowserContext extends import_browserContext.BrowserContext {
   constructor(browser, browserContextId, options) {
     super(browser, options, browserContextId);
+    this._originToPermissions = /* @__PURE__ */ new Map();
+    this._blockingPageCreations = /* @__PURE__ */ new Set();
+    this._initScriptIds = /* @__PURE__ */ new Map();
     this._authenticateProxyViaHeader();
   }
   _bidiPages() {
-    return [...this._browser._bidiPages.values()].filter(bidiPage => bidiPage._browserContext === this);
+    return [...this._browser._bidiPages.values()].filter((bidiPage) => bidiPage._browserContext === this);
+  }
+  async _initialize() {
+    const promises = [
+      super._initialize()
+    ];
+    promises.push(this.doUpdateDefaultViewport());
+    if (this._options.geolocation)
+      promises.push(this.setGeolocation(this._options.geolocation));
+    await Promise.all(promises);
   }
   possiblyUninitializedPages() {
-    return this._bidiPages().map(bidiPage => bidiPage._page);
+    return this._bidiPages().map((bidiPage) => bidiPage._page);
+  }
+  async doCreateNewPage(markAsServerSideOnly) {
+    const promise = this._createNewPageImpl(markAsServerSideOnly);
+    if (markAsServerSideOnly)
+      this._blockingPageCreations.add(promise);
+    try {
+      return await promise;
+    } finally {
+      this._blockingPageCreations.delete(promise);
+    }
   }
-  async doCreateNewPage() {
-    (0, _browserContext.assertBrowserContextIsNotOwned)(this);
-    const {
-      context
-    } = await this._browser._browserSession.send('browsingContext.create', {
+  async _createNewPageImpl(markAsServerSideOnly) {
+    const { context } = await this._browser._browserSession.send("browsingContext.create", {
       type: bidi.BrowsingContext.CreateType.Window,
       userContext: this._browserContextId
     });
-    return this._browser._bidiPages.get(context)._page;
+    const page = this._browser._bidiPages.get(context)._page;
+    if (markAsServerSideOnly)
+      page.markAsServerSideOnly();
+    return page;
+  }
+  async waitForBlockingPageCreations() {
+    await Promise.all([...this._blockingPageCreations].map((command) => command.catch(() => {
+    })));
   }
   async doGetCookies(urls) {
-    const {
-      cookies
-    } = await this._browser._browserSession.send('storage.getCookies', {
-      partition: {
-        type: 'storageKey',
-        userContext: this._browserContextId
-      }
-    });
-    return network.filterCookies(cookies.map(c => {
-      var _c$expiry;
+    const { cookies } = await this._browser._browserSession.send(
+      "storage.getCookies",
+      { partition: { type: "storageKey", userContext: this._browserContextId } }
+    );
+    return network.filterCookies(cookies.map((c) => {
       const copy = {
         name: c.name,
-        value: (0, _bidiNetworkManager.bidiBytesValueToString)(c.value),
+        value: (0, import_bidiNetworkManager.bidiBytesValueToString)(c.value),
         domain: c.domain,
         path: c.path,
         httpOnly: c.httpOnly,
         secure: c.secure,
-        expires: (_c$expiry = c.expiry) !== null && _c$expiry !== void 0 ? _c$expiry : -1,
-        sameSite: c.sameSite ? fromBidiSameSite(c.sameSite) : 'None'
+        expires: c.expiry ?? -1,
+        sameSite: c.sameSite ? fromBidiSameSite(c.sameSite) : "None"
       };
       return copy;
     }), urls);
   }
   async addCookies(cookies) {
     cookies = network.rewriteCookies(cookies);
-    const promises = cookies.map(c => {
+    const promises = cookies.map((c) => {
       const cookie = {
         name: c.name,
-        value: {
-          type: 'string',
-          value: c.value
-        },
+        value: { type: "string", value: c.value },
         domain: c.domain,
         path: c.path,
         httpOnly: c.httpOnly,
         secure: c.secure,
         sameSite: c.sameSite && toBidiSameSite(c.sameSite),
-        expiry: c.expires === -1 || c.expires === undefined ? undefined : Math.round(c.expires)
+        expiry: c.expires === -1 || c.expires === void 0 ? void 0 : Math.round(c.expires)
       };
-      return this._browser._browserSession.send('storage.setCookie', {
-        cookie,
-        partition: {
-          type: 'storageKey',
-          userContext: this._browserContextId
-        }
-      });
+      return this._browser._browserSession.send(
+        "storage.setCookie",
+        { cookie, partition: { type: "storageKey", userContext: this._browserContextId } }
+      );
     });
     await Promise.all(promises);
   }
   async doClearCookies() {
-    await this._browser._browserSession.send('storage.deleteCookies', {
-      partition: {
-        type: 'storageKey',
-        userContext: this._browserContextId
-      }
+    await this._browser._browserSession.send(
+      "storage.deleteCookies",
+      { partition: { type: "storageKey", userContext: this._browserContextId } }
+    );
+  }
+  async doGrantPermissions(origin, permissions) {
+    const currentPermissions = this._originToPermissions.get(origin) || [];
+    const toGrant = permissions.filter((permission) => !currentPermissions.includes(permission));
+    this._originToPermissions.set(origin, [...currentPermissions, ...toGrant]);
+    await Promise.all(toGrant.map((permission) => this._setPermission(origin, permission, bidi.Permissions.PermissionState.Granted)));
+  }
+  async doClearPermissions() {
+    const currentPermissions = [...this._originToPermissions.entries()];
+    this._originToPermissions = /* @__PURE__ */ new Map();
+    await Promise.all(currentPermissions.map(([origin, permissions]) => permissions.map(
+      (p) => this._setPermission(origin, p, bidi.Permissions.PermissionState.Prompt)
+    )));
+  }
+  async _setPermission(origin, permission, state) {
+    await this._browser._browserSession.send("permissions.setPermission", {
+      descriptor: {
+        name: permission
+      },
+      state,
+      origin,
+      userContext: this._browserContextId || "default"
+    });
+  }
+  async setGeolocation(geolocation) {
+    (0, import_browserContext.verifyGeolocation)(geolocation);
+    this._options.geolocation = geolocation;
+    await this._browser._browserSession.send("emulation.setGeolocationOverride", {
+      coordinates: geolocation ? {
+        latitude: geolocation.latitude,
+        longitude: geolocation.longitude,
+        accuracy: geolocation.accuracy
+      } : null,
+      userContexts: [this._browserContextId || "default"]
     });
   }
-  async doGrantPermissions(origin, permissions) {}
-  async doClearPermissions() {}
-  async setGeolocation(geolocation) {}
-  async setExtraHTTPHeaders(headers) {}
-  async setUserAgent(userAgent) {}
-  async setOffline(offline) {}
+  async doUpdateExtraHTTPHeaders() {
+  }
+  async setUserAgent(userAgent) {
+  }
+  async doUpdateOffline() {
+  }
   async doSetHTTPCredentials(httpCredentials) {
     this._options.httpCredentials = httpCredentials;
-    for (const page of this.pages()) await page._delegate.updateHttpCredentials();
+    for (const page of this.pages())
+      await page.delegate.updateHttpCredentials();
   }
   async doAddInitScript(initScript) {
-    await Promise.all(this.pages().map(page => page._delegate.addInitScript(initScript)));
+    const { script } = await this._browser._browserSession.send("script.addPreloadScript", {
+      // TODO: remove function call from the source.
+      functionDeclaration: `() => { return ${initScript.source} }`,
+      userContexts: [this._browserContextId || "default"]
+    });
+    this._initScriptIds.set(initScript, script);
+  }
+  async doRemoveInitScripts(initScripts) {
+    const ids = [];
+    for (const script of initScripts) {
+      const id = this._initScriptIds.get(script);
+      if (id)
+        ids.push(id);
+      this._initScriptIds.delete(script);
+    }
+    await Promise.all(ids.map((script) => this._browser._browserSession.send("script.removePreloadScript", { script })));
+  }
+  async doUpdateRequestInterception() {
+  }
+  async doUpdateDefaultViewport() {
+    if (!this._options.viewport)
+      return;
+    await this._browser._browserSession.send("browsingContext.setViewport", {
+      viewport: {
+        width: this._options.viewport.width,
+        height: this._options.viewport.height
+      },
+      devicePixelRatio: this._options.deviceScaleFactor || 1,
+      userContexts: [this._userContextId()]
+    });
+  }
+  async doUpdateDefaultEmulatedMedia() {
+  }
+  async doExposePlaywrightBinding() {
+    const args = [{
+      type: "channel",
+      value: {
+        channel: import_bidiPage.kPlaywrightBindingChannel,
+        ownership: bidi.Script.ResultOwnership.Root
+      }
+    }];
+    const functionDeclaration = `function addMainBinding(callback) { globalThis['${import_page.PageBinding.kBindingName}'] = callback; }`;
+    const promises = [];
+    promises.push(this._browser._browserSession.send("script.addPreloadScript", {
+      functionDeclaration,
+      arguments: args,
+      userContexts: [this._userContextId()]
+    }));
+    promises.push(...this._bidiPages().map((page) => {
+      const realms = [...page._realmToContext].filter(([realm, context]) => context.world === "main").map(([realm, context]) => realm);
+      return Promise.all(realms.map((realm) => {
+        return page._session.send("script.callFunction", {
+          functionDeclaration,
+          arguments: args,
+          target: { realm },
+          awaitPromise: false,
+          userActivation: false
+        });
+      }));
+    }));
+    await Promise.all(promises);
+  }
+  onClosePersistent() {
+  }
+  async clearCache() {
   }
-  async doRemoveNonInternalInitScripts() {}
-  async doUpdateRequestInterception() {}
-  onClosePersistent() {}
-  async clearCache() {}
   async doClose(reason) {
     if (!this._browserContextId) {
-      // Closing persistent context should close the browser.
-      await this._browser.close({
-        reason
-      });
+      await this._browser.close({ reason });
       return;
     }
-    await this._browser._browserSession.send('browser.removeUserContext', {
+    await this._browser._browserSession.send("browser.removeUserContext", {
       userContext: this._browserContextId
     });
     this._browser._contexts.delete(this._browserContextId);
   }
-  async cancelDownload(uuid) {}
+  async cancelDownload(uuid) {
+  }
+  _userContextId() {
+    if (this._browserContextId)
+      return this._browserContextId;
+    return "default";
+  }
 }
-exports.BidiBrowserContext = BidiBrowserContext;
 function fromBidiSameSite(sameSite) {
   switch (sameSite) {
-    case 'strict':
-      return 'Strict';
-    case 'lax':
-      return 'Lax';
-    case 'none':
-      return 'None';
-  }
-  return 'None';
+    case "strict":
+      return "Strict";
+    case "lax":
+      return "Lax";
+    case "none":
+      return "None";
+  }
+  return "None";
 }
 function toBidiSameSite(sameSite) {
   switch (sameSite) {
-    case 'Strict':
+    case "Strict":
       return bidi.Network.SameSite.Strict;
-    case 'Lax':
+    case "Lax":
       return bidi.Network.SameSite.Lax;
-    case 'None':
+    case "None":
       return bidi.Network.SameSite.None;
   }
   return bidi.Network.SameSite.None;
 }
-let Network = exports.Network = void 0;
-(function (_Network) {
-  let SameSite = /*#__PURE__*/function (SameSite) {
-    SameSite["Strict"] = "strict";
-    SameSite["Lax"] = "lax";
-    SameSite["None"] = "none";
-    return SameSite;
-  }({});
-  _Network.SameSite = SameSite;
-})(Network || (exports.Network = Network = {}));
+var Network;
+((Network2) => {
+  let SameSite;
+  ((SameSite2) => {
+    SameSite2["Strict"] = "strict";
+    SameSite2["Lax"] = "lax";
+    SameSite2["None"] = "none";
+  })(SameSite = Network2.SameSite || (Network2.SameSite = {}));
+})(Network || (Network = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BidiBrowser,
+  BidiBrowserContext,
+  Network
+});