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

package/lib/client/clock.js

@@ -1,32 +1,32 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var clock_exports = {};
+__export(clock_exports, {
+  Clock: () => Clock
 });
-exports.Clock = void 0;
-/**
- * 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.
- */
-
+module.exports = __toCommonJS(clock_exports);
 class Clock {
   constructor(browserContext) {
-    this._browserContext = void 0;
     this._browserContext = browserContext;
   }
   async install(options = {}) {
-    await this._browserContext._channel.clockInstall(options.time !== undefined ? parseTime(options.time) : {});
+    await this._browserContext._channel.clockInstall(options.time !== void 0 ? parseTime(options.time) : {});
   }
   async fastForward(ticks) {
     await this._browserContext._channel.clockFastForward(parseTicks(ticks));
@@ -47,22 +47,22 @@ class Clock {
     await this._browserContext._channel.clockSetSystemTime(parseTime(time));
   }
 }
-exports.Clock = Clock;
 function parseTime(time) {
-  if (typeof time === 'number') return {
-    timeNumber: time
-  };
-  if (typeof time === 'string') return {
-    timeString: time
-  };
-  if (!isFinite(time.getTime())) throw new Error(`Invalid date: ${time}`);
-  return {
-    timeNumber: time.getTime()
-  };
+  if (typeof time === "number")
+    return { timeNumber: time };
+  if (typeof time === "string")
+    return { timeString: time };
+  if (!isFinite(time.getTime()))
+    throw new Error(`Invalid date: ${time}`);
+  return { timeNumber: time.getTime() };
 }
 function parseTicks(ticks) {
   return {
-    ticksNumber: typeof ticks === 'number' ? ticks : undefined,
-    ticksString: typeof ticks === 'string' ? ticks : undefined
+    ticksNumber: typeof ticks === "number" ? ticks : void 0,
+    ticksString: typeof ticks === "string" ? ticks : void 0
   };
-}
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Clock
+});

package/lib/client/connection.js

@@ -1,83 +1,77 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var connection_exports = {};
+__export(connection_exports, {
+  Connection: () => Connection
 });
-exports.Connection = void 0;
-var _eventEmitter = require("./eventEmitter");
-var _android = require("./android");
-var _artifact = require("./artifact");
-var _browser = require("./browser");
-var _browserContext = require("./browserContext");
-var _browserType = require("./browserType");
-var _cdpSession = require("./cdpSession");
-var _channelOwner = require("./channelOwner");
-var _clientInstrumentation = require("./clientInstrumentation");
-var _dialog = require("./dialog");
-var _electron = require("./electron");
-var _elementHandle = require("./elementHandle");
-var _errors = require("./errors");
-var _fetch = require("./fetch");
-var _frame = require("./frame");
-var _jsHandle = require("./jsHandle");
-var _jsonPipe = require("./jsonPipe");
-var _localUtils = require("./localUtils");
-var _network = require("./network");
-var _page = require("./page");
-var _playwright = require("./playwright");
-var _selectors = require("./selectors");
-var _stream = require("./stream");
-var _tracing = require("./tracing");
-var _worker = require("./worker");
-var _writableStream = require("./writableStream");
-var _validator = require("../protocol/validator");
-var _stackTrace = require("../utils/isomorphic/stackTrace");
-/**
- * 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 Root extends _channelOwner.ChannelOwner {
+module.exports = __toCommonJS(connection_exports);
+var import_eventEmitter = require("./eventEmitter");
+var import_android = require("./android");
+var import_artifact = require("./artifact");
+var import_browser = require("./browser");
+var import_browserContext = require("./browserContext");
+var import_browserType = require("./browserType");
+var import_cdpSession = require("./cdpSession");
+var import_channelOwner = require("./channelOwner");
+var import_clientInstrumentation = require("./clientInstrumentation");
+var import_dialog = require("./dialog");
+var import_electron = require("./electron");
+var import_elementHandle = require("./elementHandle");
+var import_errors = require("./errors");
+var import_fetch = require("./fetch");
+var import_frame = require("./frame");
+var import_jsHandle = require("./jsHandle");
+var import_jsonPipe = require("./jsonPipe");
+var import_localUtils = require("./localUtils");
+var import_network = require("./network");
+var import_page = require("./page");
+var import_playwright = require("./playwright");
+var import_stream = require("./stream");
+var import_tracing = require("./tracing");
+var import_worker = require("./worker");
+var import_writableStream = require("./writableStream");
+var import_validator = require("../protocol/validator");
+var import_stackTrace = require("../utils/isomorphic/stackTrace");
+class Root extends import_channelOwner.ChannelOwner {
   constructor(connection) {
-    super(connection, 'Root', '', {});
+    super(connection, "Root", "", {});
   }
   async initialize() {
-    return _playwright.Playwright.from((await this._channel.initialize({
-      sdkLanguage: 'javascript'
+    return import_playwright.Playwright.from((await this._channel.initialize({
+      sdkLanguage: "javascript"
     })).playwright);
   }
 }
-class DummyChannelOwner extends _channelOwner.ChannelOwner {}
-class Connection extends _eventEmitter.EventEmitter {
+class DummyChannelOwner extends import_channelOwner.ChannelOwner {
+}
+class Connection extends import_eventEmitter.EventEmitter {
   constructor(platform, localUtils, instrumentation, headers = []) {
     super(platform);
-    this._objects = new Map();
-    this.onmessage = message => {};
+    this._objects = /* @__PURE__ */ new Map();
+    this.onmessage = (message) => {
+    };
     this._lastId = 0;
-    this._callbacks = new Map();
-    this._rootObject = void 0;
-    this._closedError = void 0;
+    this._callbacks = /* @__PURE__ */ new Map();
     this._isRemote = false;
-    this._localUtils = void 0;
     this._rawBuffers = false;
-    // Some connections allow resolving in-process dispatchers.
-    this.toImpl = void 0;
     this._tracingCount = 0;
-    this._instrumentation = void 0;
-    // Used from @playwright/test fixtures -> TODO remove?
-    this.headers = void 0;
-    this._instrumentation = instrumentation || (0, _clientInstrumentation.createInstrumentation)();
+    this._instrumentation = instrumentation || (0, import_clientInstrumentation.createInstrumentation)();
     this._localUtils = localUtils;
     this._rootObject = new Root(this);
     this.headers = headers;
@@ -104,237 +98,217 @@ class Connection extends _eventEmitter.EventEmitter {
     return this._objects.get(guid);
   }
   setIsTracing(isTracing) {
-    if (isTracing) this._tracingCount++;else this._tracingCount--;
+    if (isTracing)
+      this._tracingCount++;
+    else
+      this._tracingCount--;
   }
-  async sendMessageToServer(object, method, params, apiName, frames, stepId) {
-    var _this$_localUtils;
-    if (this._closedError) throw this._closedError;
-    if (object._wasCollected) throw new Error('The object has been collected to prevent unbounded heap growth.');
+  async sendMessageToServer(object, method, params, options) {
+    if (this._closedError)
+      throw this._closedError;
+    if (object._wasCollected)
+      throw new Error("The object has been collected to prevent unbounded heap growth.");
     const guid = object._guid;
     const type = object._type;
     const id = ++this._lastId;
-    const message = {
-      id,
-      guid,
-      method,
-      params
-    };
-    if (this._platform.isLogEnabled('channel')) {
-      // Do not include metadata in debug logs to avoid noise.
-      this._platform.log('channel', 'SEND> ' + JSON.stringify(message));
+    const message = { id, guid, method, params };
+    if (this._platform.isLogEnabled("channel")) {
+      this._platform.log("channel", "SEND> " + JSON.stringify(message));
     }
-    const location = frames[0] ? {
-      file: frames[0].file,
-      line: frames[0].line,
-      column: frames[0].column
-    } : undefined;
-    const metadata = {
-      apiName,
-      location,
-      internal: !apiName,
-      stepId
-    };
-    if (this._tracingCount && frames && type !== 'LocalUtils') (_this$_localUtils = this._localUtils) === null || _this$_localUtils === void 0 || _this$_localUtils.addStackToTracingNoReply({
-      callData: {
-        stack: frames,
-        id
-      }
-    }).catch(() => {});
-    // We need to exit zones before calling into the server, otherwise
-    // when we receive events from the server, we would be in an API zone.
-    this._platform.zones.empty.run(() => this.onmessage({
-      ...message,
-      metadata
-    }));
-    return await new Promise((resolve, reject) => this._callbacks.set(id, {
-      resolve,
-      reject,
-      apiName,
-      type,
-      method
-    }));
+    const location = options.frames?.[0] ? { file: options.frames[0].file, line: options.frames[0].line, column: options.frames[0].column } : void 0;
+    const metadata = { title: options.title, location, internal: options.internal, stepId: options.stepId };
+    if (this._tracingCount && options.frames && type !== "LocalUtils")
+      this._localUtils?.addStackToTracingNoReply({ callData: { stack: options.frames ?? [], id } }).catch(() => {
+      });
+    this._platform.zones.empty.run(() => this.onmessage({ ...message, metadata }));
+    return await new Promise((resolve, reject) => this._callbacks.set(id, { resolve, reject, title: options.title, type, method }));
   }
   _validatorFromWireContext() {
     return {
       tChannelImpl: this._tChannelImplFromWire.bind(this),
-      binary: this._rawBuffers ? 'buffer' : 'fromBase64',
+      binary: this._rawBuffers ? "buffer" : "fromBase64",
       isUnderTest: () => this._platform.isUnderTest()
     };
   }
   dispatch(message) {
-    if (this._closedError) return;
-    const {
-      id,
-      guid,
-      method,
-      params,
-      result,
-      error,
-      log
-    } = message;
+    if (this._closedError)
+      return;
+    const { id, guid, method, params, result, error, log } = message;
     if (id) {
-      if (this._platform.isLogEnabled('channel')) this._platform.log('channel', '<RECV ' + JSON.stringify(message));
+      if (this._platform.isLogEnabled("channel"))
+        this._platform.log("channel", "<RECV " + JSON.stringify(message));
       const callback = this._callbacks.get(id);
-      if (!callback) throw new Error(`Cannot find command to respond: ${id}`);
+      if (!callback)
+        throw new Error(`Cannot find command to respond: ${id}`);
       this._callbacks.delete(id);
       if (error && !result) {
-        const parsedError = (0, _errors.parseError)(error);
-        (0, _stackTrace.rewriteErrorMessage)(parsedError, parsedError.message + formatCallLog(this._platform, log));
+        const parsedError = (0, import_errors.parseError)(error);
+        (0, import_stackTrace.rewriteErrorMessage)(parsedError, parsedError.message + formatCallLog(this._platform, log));
         callback.reject(parsedError);
       } else {
-        const validator = (0, _validator.findValidator)(callback.type, callback.method, 'Result');
-        callback.resolve(validator(result, '', this._validatorFromWireContext()));
+        const validator2 = (0, import_validator.findValidator)(callback.type, callback.method, "Result");
+        callback.resolve(validator2(result, "", this._validatorFromWireContext()));
       }
       return;
     }
-    if (this._platform.isLogEnabled('channel')) this._platform.log('channel', '<EVENT ' + JSON.stringify(message));
-    if (method === '__create__') {
+    if (this._platform.isLogEnabled("channel"))
+      this._platform.log("channel", "<EVENT " + JSON.stringify(message));
+    if (method === "__create__") {
       this._createRemoteObject(guid, params.type, params.guid, params.initializer);
       return;
     }
     const object = this._objects.get(guid);
-    if (!object) throw new Error(`Cannot find object to "${method}": ${guid}`);
-    if (method === '__adopt__') {
+    if (!object)
+      throw new Error(`Cannot find object to "${method}": ${guid}`);
+    if (method === "__adopt__") {
       const child = this._objects.get(params.guid);
-      if (!child) throw new Error(`Unknown new child: ${params.guid}`);
+      if (!child)
+        throw new Error(`Unknown new child: ${params.guid}`);
       object._adopt(child);
       return;
     }
-    if (method === '__dispose__') {
+    if (method === "__dispose__") {
       object._dispose(params.reason);
       return;
     }
-    const validator = (0, _validator.findValidator)(object._type, method, 'Event');
-    object._channel.emit(method, validator(params, '', this._validatorFromWireContext()));
+    const validator = (0, import_validator.findValidator)(object._type, method, "Event");
+    object._channel.emit(method, validator(params, "", this._validatorFromWireContext()));
   }
   close(cause) {
-    if (this._closedError) return;
-    this._closedError = new _errors.TargetClosedError(cause);
-    for (const callback of this._callbacks.values()) callback.reject(this._closedError);
+    if (this._closedError)
+      return;
+    this._closedError = new import_errors.TargetClosedError(cause);
+    for (const callback of this._callbacks.values())
+      callback.reject(this._closedError);
     this._callbacks.clear();
-    this.emit('close');
+    this.emit("close");
   }
   _tChannelImplFromWire(names, arg, path, context) {
-    if (arg && typeof arg === 'object' && typeof arg.guid === 'string') {
+    if (arg && typeof arg === "object" && typeof arg.guid === "string") {
       const object = this._objects.get(arg.guid);
-      if (!object) throw new Error(`Object with guid ${arg.guid} was not bound in the connection`);
-      if (names !== '*' && !names.includes(object._type)) throw new _validator.ValidationError(`${path}: expected channel ${names.toString()}`);
+      if (!object)
+        throw new Error(`Object with guid ${arg.guid} was not bound in the connection`);
+      if (names !== "*" && !names.includes(object._type))
+        throw new import_validator.ValidationError(`${path}: expected channel ${names.toString()}`);
       return object._channel;
     }
-    throw new _validator.ValidationError(`${path}: expected channel ${names.toString()}`);
+    throw new import_validator.ValidationError(`${path}: expected channel ${names.toString()}`);
   }
   _createRemoteObject(parentGuid, type, guid, initializer) {
     const parent = this._objects.get(parentGuid);
-    if (!parent) throw new Error(`Cannot find parent object ${parentGuid} to create ${guid}`);
+    if (!parent)
+      throw new Error(`Cannot find parent object ${parentGuid} to create ${guid}`);
     let result;
-    const validator = (0, _validator.findValidator)(type, '', 'Initializer');
-    initializer = validator(initializer, '', this._validatorFromWireContext());
+    const validator = (0, import_validator.findValidator)(type, "", "Initializer");
+    initializer = validator(initializer, "", this._validatorFromWireContext());
     switch (type) {
-      case 'Android':
-        result = new _android.Android(parent, type, guid, initializer);
-        break;
-      case 'AndroidSocket':
-        result = new _android.AndroidSocket(parent, type, guid, initializer);
+      case "Android":
+        result = new import_android.Android(parent, type, guid, initializer);
         break;
-      case 'AndroidDevice':
-        result = new _android.AndroidDevice(parent, type, guid, initializer);
+      case "AndroidSocket":
+        result = new import_android.AndroidSocket(parent, type, guid, initializer);
         break;
-      case 'APIRequestContext':
-        result = new _fetch.APIRequestContext(parent, type, guid, initializer);
+      case "AndroidDevice":
+        result = new import_android.AndroidDevice(parent, type, guid, initializer);
         break;
-      case 'Artifact':
-        result = new _artifact.Artifact(parent, type, guid, initializer);
+      case "APIRequestContext":
+        result = new import_fetch.APIRequestContext(parent, type, guid, initializer);
         break;
-      case 'BindingCall':
-        result = new _page.BindingCall(parent, type, guid, initializer);
+      case "Artifact":
+        result = new import_artifact.Artifact(parent, type, guid, initializer);
         break;
-      case 'Browser':
-        result = new _browser.Browser(parent, type, guid, initializer);
+      case "BindingCall":
+        result = new import_page.BindingCall(parent, type, guid, initializer);
         break;
-      case 'BrowserContext':
-        result = new _browserContext.BrowserContext(parent, type, guid, initializer);
+      case "Browser":
+        result = new import_browser.Browser(parent, type, guid, initializer);
         break;
-      case 'BrowserType':
-        result = new _browserType.BrowserType(parent, type, guid, initializer);
+      case "BrowserContext":
+        result = new import_browserContext.BrowserContext(parent, type, guid, initializer);
         break;
-      case 'CDPSession':
-        result = new _cdpSession.CDPSession(parent, type, guid, initializer);
+      case "BrowserType":
+        result = new import_browserType.BrowserType(parent, type, guid, initializer);
         break;
-      case 'Dialog':
-        result = new _dialog.Dialog(parent, type, guid, initializer);
+      case "CDPSession":
+        result = new import_cdpSession.CDPSession(parent, type, guid, initializer);
         break;
-      case 'Electron':
-        result = new _electron.Electron(parent, type, guid, initializer);
+      case "Dialog":
+        result = new import_dialog.Dialog(parent, type, guid, initializer);
         break;
-      case 'ElectronApplication':
-        result = new _electron.ElectronApplication(parent, type, guid, initializer);
+      case "Electron":
+        result = new import_electron.Electron(parent, type, guid, initializer);
         break;
-      case 'ElementHandle':
-        result = new _elementHandle.ElementHandle(parent, type, guid, initializer);
+      case "ElectronApplication":
+        result = new import_electron.ElectronApplication(parent, type, guid, initializer);
         break;
-      case 'Frame':
-        result = new _frame.Frame(parent, type, guid, initializer);
+      case "ElementHandle":
+        result = new import_elementHandle.ElementHandle(parent, type, guid, initializer);
         break;
-      case 'JSHandle':
-        result = new _jsHandle.JSHandle(parent, type, guid, initializer);
+      case "Frame":
+        result = new import_frame.Frame(parent, type, guid, initializer);
         break;
-      case 'JsonPipe':
-        result = new _jsonPipe.JsonPipe(parent, type, guid, initializer);
+      case "JSHandle":
+        result = new import_jsHandle.JSHandle(parent, type, guid, initializer);
         break;
-      case 'LocalUtils':
-        result = new _localUtils.LocalUtils(parent, type, guid, initializer);
-        if (!this._localUtils) this._localUtils = result;
+      case "JsonPipe":
+        result = new import_jsonPipe.JsonPipe(parent, type, guid, initializer);
         break;
-      case 'Page':
-        result = new _page.Page(parent, type, guid, initializer);
+      case "LocalUtils":
+        result = new import_localUtils.LocalUtils(parent, type, guid, initializer);
+        if (!this._localUtils)
+          this._localUtils = result;
         break;
-      case 'Playwright':
-        result = new _playwright.Playwright(parent, type, guid, initializer);
+      case "Page":
+        result = new import_page.Page(parent, type, guid, initializer);
         break;
-      case 'Request':
-        result = new _network.Request(parent, type, guid, initializer);
+      case "Playwright":
+        result = new import_playwright.Playwright(parent, type, guid, initializer);
         break;
-      case 'Response':
-        result = new _network.Response(parent, type, guid, initializer);
+      case "Request":
+        result = new import_network.Request(parent, type, guid, initializer);
         break;
-      case 'Route':
-        result = new _network.Route(parent, type, guid, initializer);
+      case "Response":
+        result = new import_network.Response(parent, type, guid, initializer);
         break;
-      case 'Stream':
-        result = new _stream.Stream(parent, type, guid, initializer);
+      case "Route":
+        result = new import_network.Route(parent, type, guid, initializer);
         break;
-      case 'Selectors':
-        result = new _selectors.SelectorsOwner(parent, type, guid, initializer);
+      case "Stream":
+        result = new import_stream.Stream(parent, type, guid, initializer);
         break;
-      case 'SocksSupport':
+      case "SocksSupport":
         result = new DummyChannelOwner(parent, type, guid, initializer);
         break;
-      case 'Tracing':
-        result = new _tracing.Tracing(parent, type, guid, initializer);
+      case "Tracing":
+        result = new import_tracing.Tracing(parent, type, guid, initializer);
         break;
-      case 'WebSocket':
-        result = new _network.WebSocket(parent, type, guid, initializer);
+      case "WebSocket":
+        result = new import_network.WebSocket(parent, type, guid, initializer);
         break;
-      case 'WebSocketRoute':
-        result = new _network.WebSocketRoute(parent, type, guid, initializer);
+      case "WebSocketRoute":
+        result = new import_network.WebSocketRoute(parent, type, guid, initializer);
         break;
-      case 'Worker':
-        result = new _worker.Worker(parent, type, guid, initializer);
+      case "Worker":
+        result = new import_worker.Worker(parent, type, guid, initializer);
         break;
-      case 'WritableStream':
-        result = new _writableStream.WritableStream(parent, type, guid, initializer);
+      case "WritableStream":
+        result = new import_writableStream.WritableStream(parent, type, guid, initializer);
         break;
       default:
-        throw new Error('Missing type ' + type);
+        throw new Error("Missing type " + type);
     }
     return result;
   }
 }
-exports.Connection = Connection;
 function formatCallLog(platform, log) {
-  if (!log || !log.some(l => !!l)) return '';
+  if (!log || !log.some((l) => !!l))
+    return "";
   return `
 Call log:
-${platform.colors.dim(log.join('\n'))}
+${platform.colors.dim(log.join("\n"))}
 `;
-}
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Connection
+});