@checkly/playwright-core 1.42.18 → 1.47.11

package/lib/server/firefox/ffBrowser.js

@@ -9,6 +9,7 @@ var _utils = require("../../utils");
 var _browser = require("../browser");
 var _browserContext = require("../browserContext");
 var network = _interopRequireWildcard(require("../network"));
+var _page = require("../page");
 var _ffConnection = require("./ffConnection");
 var _ffPage = require("./ffPage");
 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); }
@@ -165,7 +166,11 @@ class FFBrowserContext extends _browserContext.BrowserContext {
   async _initialize() {
     (0, _utils.assert)(!this._ffPages().length);
     const browserContextId = this._browserContextId;
-    const promises = [super._initialize()];
+    const promises = [super._initialize(), this._browser.session.send('Browser.addBinding', {
+      browserContextId: this._browserContextId,
+      name: _page.PageBinding.kPlaywrightBinding,
+      script: ''
+    })];
     if (this._options.acceptDownloads !== 'internal-browser-default') {
       promises.push(this._browser.session.send('Browser.setDownloadOptions', {
         browserContextId,
@@ -301,7 +306,7 @@ class FFBrowserContext extends _browserContext.BrowserContext {
       cookies: cc
     });
   }
-  async clearCookies() {
+  async doClearCookies() {
     await this._browser.session.send('Browser.clearCookies', {
       browserContextId: this._browserContextId
     });
@@ -356,42 +361,48 @@ class FFBrowserContext extends _browserContext.BrowserContext {
   }
   async doSetHTTPCredentials(httpCredentials) {
     this._options.httpCredentials = httpCredentials;
+    let credentials = null;
+    if (httpCredentials) {
+      const {
+        username,
+        password,
+        origin
+      } = httpCredentials;
+      credentials = {
+        username,
+        password,
+        origin
+      };
+    }
     await this._browser.session.send('Browser.setHTTPCredentials', {
       browserContextId: this._browserContextId,
-      credentials: httpCredentials || null
+      credentials
     });
   }
-  async doAddInitScript(source) {
+  async doAddInitScript(initScript) {
+    await this._updateInitScripts();
+  }
+  async doRemoveNonInternalInitScripts() {
+    await this._updateInitScripts();
+  }
+  async _updateInitScripts() {
+    const bindingScripts = [...this._pageBindings.values()].map(binding => binding.initScript.source);
+    const initScripts = this.initScripts.map(script => script.source);
     await this._browser.session.send('Browser.setInitScripts', {
       browserContextId: this._browserContextId,
-      scripts: this.initScripts.map(script => ({
+      scripts: [...bindingScripts, ...initScripts].map(script => ({
         script
       }))
     });
   }
-  async doRemoveInitScripts() {
-    await this._browser.session.send('Browser.setInitScripts', {
-      browserContextId: this._browserContextId,
-      scripts: []
-    });
-  }
-  async doExposeBinding(binding) {
-    await this._browser.session.send('Browser.addBinding', {
-      browserContextId: this._browserContextId,
-      name: binding.name,
-      script: binding.source
-    });
-  }
-  async doRemoveExposedBindings() {
-    // TODO: implement me.
-    // This is not a critical problem, what ends up happening is
-    // an old binding will be restored upon page reload and will point nowhere.
-  }
   async doUpdateRequestInterception() {
-    await this._browser.session.send('Browser.setRequestInterception', {
+    await Promise.all([this._browser.session.send('Browser.setRequestInterception', {
       browserContextId: this._browserContextId,
       enabled: !!this._requestInterceptor
-    });
+    }), this._browser.session.send('Browser.setCacheDisabled', {
+      browserContextId: this._browserContextId,
+      cacheDisabled: !!this._requestInterceptor
+    })]);
   }
   onClosePersistent() {}
   async clearCache() {

package/lib/server/firefox/ffConnection.js

@@ -69,11 +69,11 @@ class FFConnection extends _events.EventEmitter {
     const session = this._sessions.get(message.sessionId || '');
     if (session) session.dispatchMessage(message);
   }
-  _onClose() {
+  _onClose(reason) {
     this._closed = true;
     this._transport.onmessage = undefined;
     this._transport.onclose = undefined;
-    this._browserDisconnectedLogs = _helper.helper.formatBrowserLogs(this._browserLogsCollector.recentLogs());
+    this._browserDisconnectedLogs = _helper.helper.formatBrowserLogs(this._browserLogsCollector.recentLogs(), reason);
     this.rootSession.dispose();
     Promise.resolve().then(() => this.emit(ConnectionEvents.Disconnected));
   }

package/lib/server/firefox/ffNetworkManager.js

@@ -40,9 +40,11 @@ class FFNetworkManager {
     _eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
   }
   async setRequestInterception(enabled) {
-    await this._session.send('Network.setRequestInterception', {
+    await Promise.all([this._session.send('Network.setRequestInterception', {
       enabled
-    });
+    }), this._session.send('Page.setCacheDisabled', {
+      cacheDisabled: enabled
+    })]);
   }
   _onRequestWillBeSent(event) {
     const redirectedFrom = event.redirectedFrom ? this._requests.get(event.redirectedFrom) || null : null;
@@ -191,7 +193,7 @@ class FFRouteImpl {
     this._session = session;
     this._request = request;
   }
-  async continue(request, overrides) {
+  async continue(overrides) {
     await this._session.sendMayFail('Network.resumeInterceptedRequest', {
       requestId: this._request._id,
       url: overrides.url,
@@ -205,7 +207,7 @@ class FFRouteImpl {
     await this._session.sendMayFail('Network.fulfillInterceptedRequest', {
       requestId: this._request._id,
       status: response.status,
-      statusText: network.STATUS_TEXTS[String(response.status)] || '',
+      statusText: network.statusText(response.status),
       headers: response.headers,
       base64body
     });

package/lib/server/firefox/ffPage.js

@@ -40,7 +40,7 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
 const UTILITY_WORLD_NAME = exports.UTILITY_WORLD_NAME = '__playwright_utility_world__';
 class FFPage {
   constructor(session, browserContext, opener) {
-    this.cspErrorsAsynchronousForInlineScipts = true;
+    this.cspErrorsAsynchronousForInlineScripts = true;
     this.rawMouse = void 0;
     this.rawKeyboard = void 0;
     this.rawTouchscreen = void 0;
@@ -81,7 +81,7 @@ class FFPage {
     });
     // Ideally, we somehow ensure that utility world is created before Page.ready arrives, but currently it is racy.
     // Therefore, we can end up with an initialized page without utility world, although very unlikely.
-    this.addInitScript('', UTILITY_WORLD_NAME).catch(e => this._markAsError(e));
+    this.addInitScript(new _page.InitScript('', true), UTILITY_WORLD_NAME).catch(e => this._markAsError(e));
   }
   potentiallyUninitializedPage() {
     return this._page;
@@ -121,11 +121,11 @@ class FFPage {
     const frame = this._page._frameManager.frame(auxData.frameId);
     if (!frame) return;
     const delegate = new _ffExecutionContext.FFExecutionContext(this._session, executionContextId);
-    let worldName = null;
-    if (auxData.name === UTILITY_WORLD_NAME) worldName = 'utility';else if (!auxData.name) worldName = 'main';
+    let worldName;
+    if (auxData.name === UTILITY_WORLD_NAME) worldName = 'utility';else if (!auxData.name) worldName = 'main';else return;
     const context = new dom.FrameExecutionContext(delegate, frame, worldName);
     context[contextDelegateSymbol] = delegate;
-    if (worldName) frame._contextCreated(worldName, context);
+    frame._contextCreated(worldName, context);
     this._contextIdToContext.set(executionContextId, context);
   }
   _onExecutionContextDestroyed(payload) {
@@ -200,7 +200,8 @@ class FFPage {
     } = payload;
     const context = this._contextIdToContext.get(executionContextId);
     if (!context) return;
-    this._page._addConsoleMessage(type, args.map(arg => context.createHandle(arg)), location);
+    // Juggler reports 'warn' for some internal messages generated by the browser.
+    this._page._addConsoleMessage(type === 'warn' ? 'warning' : type, args.map(arg => context.createHandle(arg)), location);
   }
   _onDialogOpened(params) {
     this._page.emitOnContext(_browserContext.BrowserContext.Events.Dialog, new dialog.Dialog(this._page, params.type, params.message, async (accept, promptText) => {
@@ -287,15 +288,6 @@ class FFPage {
   _onVideoRecordingStarted(event) {
     this._browserContext._browser._videoStarted(this._browserContext, event.screencastId, event.file, this.pageOrError());
   }
-  async exposeBinding(binding) {
-    await this._session.send('Page.addBinding', {
-      name: binding.name,
-      script: binding.source
-    });
-  }
-  async removeExposedBindings() {
-    // TODO: implement me.
-  }
   didClose() {
     this._markAsError(new _errors.TargetClosedError());
     this._session.dispose();
@@ -368,19 +360,25 @@ class FFPage {
     });
     return success;
   }
-  async addInitScript(script, worldName) {
+  async addInitScript(initScript, worldName) {
     this._initScripts.push({
-      script,
+      initScript,
       worldName
     });
     await this._session.send('Page.setInitScripts', {
-      scripts: this._initScripts
+      scripts: this._initScripts.map(s => ({
+        script: s.initScript.source,
+        worldName: s.worldName
+      }))
     });
   }
-  async removeInitScripts() {
-    this._initScripts = [];
+  async removeNonInternalInitScripts() {
+    this._initScripts = this._initScripts.filter(s => s.initScript.internal);
     await this._session.send('Page.setInitScripts', {
-      scripts: []
+      scripts: this._initScripts.map(s => ({
+        script: s.initScript.source,
+        worldName: s.worldName
+      }))
     });
   }
   async closePage(runBeforeUnload) {
@@ -509,12 +507,12 @@ class FFPage {
   async setInputFiles(handle, files) {
     await handle.evaluateInUtility(([injected, node, files]) => injected.setInputFiles(node, files), files);
   }
-  async setInputFilePaths(progress, handle, files) {
-    await Promise.all([this._session.send('Page.setFileInputFiles', {
+  async setInputFilePaths(handle, files) {
+    await this._session.send('Page.setFileInputFiles', {
       frameId: handle._context.frame._id,
       objectId: handle._objectId,
       files
-    }), handle.dispatchEvent(progress.metadata, 'input'), handle.dispatchEvent(progress.metadata, 'change')]);
+    });
   }
   async adoptElementHandle(handle, to) {
     const result = await this._session.send('Page.adoptNode', {

package/lib/server/firefox/firefox.js

@@ -34,17 +34,17 @@ class Firefox extends _browserType.BrowserType {
   constructor(parent) {
     super(parent, 'firefox');
   }
-  _connectToTransport(transport, options) {
+  connectToTransport(transport, options) {
     return _ffBrowser.FFBrowser.connect(this.attribution.playwright, transport, options);
   }
-  _doRewriteStartupLog(error) {
+  doRewriteStartupLog(error) {
     if (!error.logs) return error;
     // https://github.com/microsoft/playwright/issues/6500
     if (error.logs.includes(`as root in a regular user's session is not supported.`)) error.logs = '\n' + (0, _utils.wrapInASCIIBox)(`Firefox is unable to launch if the $HOME folder isn't owned by the current user.\nWorkaround: Set the HOME=/root environment variable${process.env.GITHUB_ACTION ? ' in your GitHub Actions workflow file' : ''} when running Playwright.`, 1);
     if (error.logs.includes('no DISPLAY environment variable specified')) error.logs = '\n' + (0, _utils.wrapInASCIIBox)(_browserType.kNoXServerRunningError, 1);
     return error;
   }
-  _amendEnvironment(env, userDataDir, executable, browserArguments) {
+  amendEnvironment(env, userDataDir, executable, browserArguments) {
     if (!_path.default.isAbsolute(os.homedir())) throw new Error(`Cannot launch Firefox with relative home directory. Did you set ${os.platform() === 'win32' ? 'USERPROFILE' : 'HOME'} to a relative path?`);
     if (os.platform() === 'linux') {
       // Always remove SNAP_NAME and SNAP_INSTANCE_NAME env variables since they
@@ -58,7 +58,7 @@ class Firefox extends _browserType.BrowserType {
     }
     return env;
   }
-  _attemptToGracefullyCloseBrowser(transport) {
+  attemptToGracefullyCloseBrowser(transport) {
     const message = {
       method: 'Browser.close',
       params: {},
@@ -66,7 +66,7 @@ class Firefox extends _browserType.BrowserType {
     };
     transport.send(message);
   }
-  _defaultArgs(options, isPersistent, userDataDir) {
+  defaultArgs(options, isPersistent, userDataDir) {
     const {
       args = [],
       headless
@@ -87,5 +87,24 @@ class Firefox extends _browserType.BrowserType {
     if (isPersistent) firefoxArguments.push('about:blank');else firefoxArguments.push('-silent');
     return firefoxArguments;
   }
+  readyState(options) {
+    return new JugglerReadyState();
+  }
 }
-exports.Firefox = Firefox;
+exports.Firefox = Firefox;
+class JugglerReadyState {
+  constructor() {
+    this._jugglerPromise = new _utils.ManualPromise();
+  }
+  onBrowserOutput(message) {
+    if (message.includes('Juggler listening to the pipe')) this._jugglerPromise.resolve();
+  }
+  onBrowserExit() {
+    // Unblock launch when browser prematurely exits.
+    this._jugglerPromise.resolve();
+  }
+  async waitUntilReady() {
+    await this._jugglerPromise;
+    return {};
+  }
+}

package/lib/server/frameSelectors.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.FrameSelectors = void 0;
 var _selectorParser = require("../utils/isomorphic/selectorParser");
-var _locatorGenerators = require("../utils/isomorphic/locatorGenerators");
+var _utils = require("../utils");
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -111,7 +111,7 @@ class FrameSelectors {
     for (const chunk of frameChunks) {
       (0, _selectorParser.visitAllSelectorParts)(chunk, (part, nested) => {
         if (nested && part.name === 'internal:control' && part.body === 'enter-frame') {
-          const locator = (0, _locatorGenerators.asLocator)(this.frame._page.attribution.playwright.options.sdkLanguage, selector);
+          const locator = (0, _utils.asLocator)(this.frame._page.attribution.playwright.options.sdkLanguage, selector);
           throw new _selectorParser.InvalidSelectorError(`Frame locators are not allowed inside composite locators, while querying "${locator}"`);
         }
       });