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

package/lib/server/input.js

@@ -1,91 +1,100 @@
 "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 input_exports = {};
+__export(input_exports, {
+  Keyboard: () => Keyboard,
+  Mouse: () => Mouse,
+  Touchscreen: () => Touchscreen,
+  keypadLocation: () => keypadLocation,
+  resolveSmartModifier: () => resolveSmartModifier,
+  resolveSmartModifierString: () => resolveSmartModifierString
 });
-exports.keypadLocation = exports.Touchscreen = exports.Mouse = exports.Keyboard = void 0;
-exports.resolveSmartModifier = resolveSmartModifier;
-exports.resolveSmartModifierString = resolveSmartModifierString;
-var _utils = require("../utils");
-var keyboardLayout = _interopRequireWildcard(require("./usKeyboardLayout"));
-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.
- */
-
-const keypadLocation = exports.keypadLocation = keyboardLayout.keypadLocation;
-const kModifiers = ['Alt', 'Control', 'Meta', 'Shift'];
+module.exports = __toCommonJS(input_exports);
+var import_utils = require("../utils");
+var keyboardLayout = __toESM(require("./usKeyboardLayout"));
+const keypadLocation = keyboardLayout.keypadLocation;
+const kModifiers = ["Alt", "Control", "Meta", "Shift"];
 class Keyboard {
-  constructor(raw) {
-    this._pressedModifiers = new Set();
-    this._pressedKeys = new Set();
-    this._raw = void 0;
+  constructor(raw, page) {
+    this._pressedModifiers = /* @__PURE__ */ new Set();
+    this._pressedKeys = /* @__PURE__ */ new Set();
     this._raw = raw;
+    this._page = page;
   }
-  async down(key) {
+  async down(progress, key) {
     const description = this._keyDescriptionForString(key);
     const autoRepeat = this._pressedKeys.has(description.code);
     this._pressedKeys.add(description.code);
-    if (kModifiers.includes(description.key)) this._pressedModifiers.add(description.key);
-    await this._raw.keydown(this._pressedModifiers, key, description, autoRepeat);
+    if (kModifiers.includes(description.key))
+      this._pressedModifiers.add(description.key);
+    await this._raw.keydown(progress, this._pressedModifiers, key, description, autoRepeat);
   }
   _keyDescriptionForString(str) {
     const keyString = resolveSmartModifierString(str);
     let description = usKeyboardLayout.get(keyString);
-    (0, _utils.assert)(description, `Unknown key: "${keyString}"`);
-    const shift = this._pressedModifiers.has('Shift');
+    (0, import_utils.assert)(description, `Unknown key: "${keyString}"`);
+    const shift = this._pressedModifiers.has("Shift");
     description = shift && description.shifted ? description.shifted : description;
-
-    // if any modifiers besides shift are pressed, no text should be sent
-    if (this._pressedModifiers.size > 1 || !this._pressedModifiers.has('Shift') && this._pressedModifiers.size === 1) return {
-      ...description,
-      text: ''
-    };
+    if (this._pressedModifiers.size > 1 || !this._pressedModifiers.has("Shift") && this._pressedModifiers.size === 1)
+      return { ...description, text: "" };
     return description;
   }
-  async up(key) {
+  async up(progress, key) {
     const description = this._keyDescriptionForString(key);
-    if (kModifiers.includes(description.key)) this._pressedModifiers.delete(description.key);
+    if (kModifiers.includes(description.key))
+      this._pressedModifiers.delete(description.key);
     this._pressedKeys.delete(description.code);
-    await this._raw.keyup(this._pressedModifiers, key, description);
+    await this._raw.keyup(progress, this._pressedModifiers, key, description);
   }
-  async insertText(text) {
-    await this._raw.sendText(text);
+  async insertText(progress, text) {
+    await this._raw.sendText(progress, text);
   }
-  async type(text, options) {
-    const delay = options && options.delay || undefined;
+  async type(progress, text, options) {
+    const delay = options && options.delay || void 0;
     for (const char of text) {
       if (usKeyboardLayout.has(char)) {
-        await this.press(char, {
-          delay
-        });
+        await this.press(progress, char, { delay });
       } else {
-        if (delay) await new Promise(f => setTimeout(f, delay));
-        await this.insertText(char);
+        if (delay)
+          await progress.wait(delay);
+        await this.insertText(progress, char);
       }
     }
   }
-  async press(key, options = {}) {
+  async press(progress, key, options = {}) {
     function split(keyString) {
       const keys = [];
-      let building = '';
+      let building = "";
       for (const char of keyString) {
-        if (char === '+' && building) {
+        if (char === "+" && building) {
           keys.push(building);
-          building = '';
+          building = "";
         } else {
           building += char;
         }
@@ -95,22 +104,29 @@ class Keyboard {
     }
     const tokens = split(key);
     key = tokens[tokens.length - 1];
-    for (let i = 0; i < tokens.length - 1; ++i) await this.down(tokens[i]);
-    await this.down(key);
-    if (options.delay) await new Promise(f => setTimeout(f, options.delay));
-    await this.up(key);
-    for (let i = tokens.length - 2; i >= 0; --i) await this.up(tokens[i]);
+    for (let i = 0; i < tokens.length - 1; ++i)
+      await this.down(progress, tokens[i]);
+    await this.down(progress, key);
+    if (options.delay)
+      await progress.wait(options.delay);
+    await this.up(progress, key);
+    for (let i = tokens.length - 2; i >= 0; --i)
+      await this.up(progress, tokens[i]);
   }
-  async ensureModifiers(mm) {
+  async ensureModifiers(progress, mm) {
     const modifiers = mm.map(resolveSmartModifier);
     for (const modifier of modifiers) {
-      if (!kModifiers.includes(modifier)) throw new Error('Unknown modifier ' + modifier);
+      if (!kModifiers.includes(modifier))
+        throw new Error("Unknown modifier " + modifier);
     }
     const restore = Array.from(this._pressedModifiers);
     for (const key of kModifiers) {
       const needDown = modifiers.includes(key);
       const isDown = this._pressedModifiers.has(key);
-      if (needDown && !isDown) await this.down(key);else if (!needDown && isDown) await this.up(key);
+      if (needDown && !isDown)
+        await this.down(progress, key);
+      else if (!needDown && isDown)
+        await this.up(progress, key);
     }
     return restore;
   }
@@ -118,9 +134,9 @@ class Keyboard {
     return this._pressedModifiers;
   }
 }
-exports.Keyboard = Keyboard;
 function resolveSmartModifierString(key) {
-  if (key === 'ControlOrMeta') return process.platform === 'darwin' ? 'Meta' : 'Control';
+  if (key === "ControlOrMeta")
+    return process.platform === "darwin" ? "Meta" : "Control";
   return key;
 }
 function resolveSmartModifier(m) {
@@ -128,25 +144,19 @@ function resolveSmartModifier(m) {
 }
 class Mouse {
   constructor(raw, page) {
-    this._keyboard = void 0;
     this._x = 0;
     this._y = 0;
-    this._lastButton = 'none';
-    this._buttons = new Set();
-    this._raw = void 0;
-    this._page = void 0;
+    this._lastButton = "none";
+    this._buttons = /* @__PURE__ */ new Set();
     this._raw = raw;
     this._page = page;
     this._keyboard = this._page.keyboard;
   }
-  async move(x, y, options = {}, metadata) {
-    if (metadata) metadata.point = {
-      x,
-      y
-    };
-    const {
-      steps = 1
-    } = options;
+  currentPoint() {
+    return { x: this._x, y: this._y };
+  }
+  async move(progress, x, y, options = {}) {
+    const { steps = 1 } = options;
     const fromX = this._x;
     const fromY = this._y;
     this._x = x;
@@ -154,156 +164,108 @@ class Mouse {
     for (let i = 1; i <= steps; i++) {
       const middleX = fromX + (x - fromX) * (i / steps);
       const middleY = fromY + (y - fromY) * (i / steps);
-      await this._raw.move(middleX, middleY, this._lastButton, this._buttons, this._keyboard._modifiers(), !!options.forClick);
+      await this._raw.move(progress, middleX, middleY, this._lastButton, this._buttons, this._keyboard._modifiers(), !!options.forClick);
     }
   }
-  async down(options = {}, metadata) {
-    if (metadata) metadata.point = {
-      x: this._x,
-      y: this._y
-    };
-    const {
-      button = 'left',
-      clickCount = 1
-    } = options;
+  async down(progress, options = {}) {
+    const { button = "left", clickCount = 1 } = options;
     this._lastButton = button;
     this._buttons.add(button);
-    await this._raw.down(this._x, this._y, this._lastButton, this._buttons, this._keyboard._modifiers(), clickCount);
+    await this._raw.down(progress, this._x, this._y, this._lastButton, this._buttons, this._keyboard._modifiers(), clickCount);
   }
-  async up(options = {}, metadata) {
-    if (metadata) metadata.point = {
-      x: this._x,
-      y: this._y
-    };
-    const {
-      button = 'left',
-      clickCount = 1
-    } = options;
-    this._lastButton = 'none';
+  async up(progress, options = {}) {
+    const { button = "left", clickCount = 1 } = options;
+    this._lastButton = "none";
     this._buttons.delete(button);
-    await this._raw.up(this._x, this._y, button, this._buttons, this._keyboard._modifiers(), clickCount);
+    await this._raw.up(progress, this._x, this._y, button, this._buttons, this._keyboard._modifiers(), clickCount);
   }
-  async click(x, y, options = {}, metadata) {
-    if (metadata) metadata.point = {
-      x,
-      y
-    };
-    const {
-      delay = null,
-      clickCount = 1
-    } = options;
+  async click(progress, x, y, options = {}) {
+    const { delay = null, clickCount = 1 } = options;
     if (delay) {
-      this.move(x, y, {
-        forClick: true
-      });
+      this.move(progress, x, y, { forClick: true });
       for (let cc = 1; cc <= clickCount; ++cc) {
-        await this.down({
-          ...options,
-          clickCount: cc
-        });
-        await new Promise(f => setTimeout(f, delay));
-        await this.up({
-          ...options,
-          clickCount: cc
-        });
-        if (cc < clickCount) await new Promise(f => setTimeout(f, delay));
+        await this.down(progress, { ...options, clickCount: cc });
+        await progress.wait(delay);
+        await this.up(progress, { ...options, clickCount: cc });
+        if (cc < clickCount)
+          await progress.wait(delay);
       }
     } else {
       const promises = [];
-      promises.push(this.move(x, y, {
-        forClick: true
-      }));
+      promises.push(this.move(progress, x, y, { forClick: true }));
       for (let cc = 1; cc <= clickCount; ++cc) {
-        promises.push(this.down({
-          ...options,
-          clickCount: cc
-        }));
-        promises.push(this.up({
-          ...options,
-          clickCount: cc
-        }));
+        promises.push(this.down(progress, { ...options, clickCount: cc }));
+        promises.push(this.up(progress, { ...options, clickCount: cc }));
       }
       await Promise.all(promises);
     }
   }
-  async dblclick(x, y, options = {}) {
-    await this.click(x, y, {
-      ...options,
-      clickCount: 2
-    });
-  }
-  async wheel(deltaX, deltaY) {
-    await this._raw.wheel(this._x, this._y, this._buttons, this._keyboard._modifiers(), deltaX, deltaY);
+  async wheel(progress, deltaX, deltaY) {
+    await this._raw.wheel(progress, this._x, this._y, this._buttons, this._keyboard._modifiers(), deltaX, deltaY);
   }
 }
-exports.Mouse = Mouse;
-const aliases = new Map([['ShiftLeft', ['Shift']], ['ControlLeft', ['Control']], ['AltLeft', ['Alt']], ['MetaLeft', ['Meta']], ['Enter', ['\n', '\r']]]);
+const aliases = /* @__PURE__ */ new Map([
+  ["ShiftLeft", ["Shift"]],
+  ["ControlLeft", ["Control"]],
+  ["AltLeft", ["Alt"]],
+  ["MetaLeft", ["Meta"]],
+  ["Enter", ["\n", "\r"]]
+]);
 const usKeyboardLayout = buildLayoutClosure(keyboardLayout.USKeyboardLayout);
 function buildLayoutClosure(layout) {
-  const result = new Map();
+  const result = /* @__PURE__ */ new Map();
   for (const code in layout) {
     const definition = layout[code];
     const description = {
-      key: definition.key || '',
+      key: definition.key || "",
       keyCode: definition.keyCode || 0,
       keyCodeWithoutLocation: definition.keyCodeWithoutLocation || definition.keyCode || 0,
       code,
-      text: definition.text || '',
+      text: definition.text || "",
       location: definition.location || 0
     };
-    if (definition.key.length === 1) description.text = description.key;
-
-    // Generate shifted definition.
+    if (definition.key.length === 1)
+      description.text = description.key;
     let shiftedDescription;
     if (definition.shiftKey) {
-      (0, _utils.assert)(definition.shiftKey.length === 1);
-      shiftedDescription = {
-        ...description
-      };
+      (0, import_utils.assert)(definition.shiftKey.length === 1);
+      shiftedDescription = { ...description };
       shiftedDescription.key = definition.shiftKey;
       shiftedDescription.text = definition.shiftKey;
-      if (definition.shiftKeyCode) shiftedDescription.keyCode = definition.shiftKeyCode;
+      if (definition.shiftKeyCode)
+        shiftedDescription.keyCode = definition.shiftKeyCode;
     }
-
-    // Map from code: Digit3 -> { ... description, shifted }
-    result.set(code, {
-      ...description,
-      shifted: shiftedDescription
-    });
-
-    // Map from aliases: Shift -> non-shiftable definition
+    result.set(code, { ...description, shifted: shiftedDescription });
     if (aliases.has(code)) {
-      for (const alias of aliases.get(code)) result.set(alias, description);
+      for (const alias of aliases.get(code))
+        result.set(alias, description);
     }
-
-    // Do not use numpad when converting keys to codes.
-    if (definition.location) continue;
-
-    // Map from key, no shifted
-    if (description.key.length === 1) result.set(description.key, description);
-
-    // Map from shiftKey, no shifted
-    if (shiftedDescription) result.set(shiftedDescription.key, {
-      ...shiftedDescription,
-      shifted: undefined
-    });
+    if (definition.location)
+      continue;
+    if (description.key.length === 1)
+      result.set(description.key, description);
+    if (shiftedDescription)
+      result.set(shiftedDescription.key, { ...shiftedDescription, shifted: void 0 });
   }
   return result;
 }
 class Touchscreen {
   constructor(raw, page) {
-    this._raw = void 0;
-    this._page = void 0;
     this._raw = raw;
     this._page = page;
   }
-  async tap(x, y, metadata) {
-    if (metadata) metadata.point = {
-      x,
-      y
-    };
-    if (!this._page._browserContext._options.hasTouch) throw new Error('hasTouch must be enabled on the browser context before using the touchscreen.');
-    await this._raw.tap(x, y, this._page.keyboard._modifiers());
+  async tap(progress, x, y) {
+    if (!this._page.browserContext._options.hasTouch)
+      throw new Error("hasTouch must be enabled on the browser context before using the touchscreen.");
+    await this._raw.tap(progress, x, y, this._page.keyboard._modifiers());
   }
 }
-exports.Touchscreen = Touchscreen;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Keyboard,
+  Mouse,
+  Touchscreen,
+  keypadLocation,
+  resolveSmartModifier,
+  resolveSmartModifierString
+});

package/lib/server/instrumentation.js

@@ -1,56 +1,62 @@
 "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 instrumentation_exports = {};
+__export(instrumentation_exports, {
+  SdkObject: () => SdkObject,
+  createInstrumentation: () => createInstrumentation,
+  createRootSdkObject: () => createRootSdkObject,
+  serverSideCallMetadata: () => serverSideCallMetadata
 });
-exports.SdkObject = void 0;
-exports.createInstrumentation = createInstrumentation;
-exports.serverSideCallMetadata = serverSideCallMetadata;
-var _events = require("events");
-var _crypto = require("./utils/crypto");
-/**
- * Copyright (c) Microsoft Corporation. All rights reserved.
- *
- * 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 SdkObject extends _events.EventEmitter {
+module.exports = __toCommonJS(instrumentation_exports);
+var import_events = require("events");
+var import_crypto = require("./utils/crypto");
+class SdkObject extends import_events.EventEmitter {
   constructor(parent, guidPrefix, guid) {
     super();
-    this.guid = void 0;
-    this.attribution = void 0;
-    this.instrumentation = void 0;
-    this.guid = guid || `${guidPrefix || ''}@${(0, _crypto.createGuid)()}`;
+    this.guid = guid || `${guidPrefix || ""}@${(0, import_crypto.createGuid)()}`;
     this.setMaxListeners(0);
-    this.attribution = {
-      ...parent.attribution
-    };
+    this.attribution = { ...parent.attribution };
     this.instrumentation = parent.instrumentation;
   }
 }
-exports.SdkObject = SdkObject;
+function createRootSdkObject() {
+  const fakeParent = { attribution: {}, instrumentation: createInstrumentation() };
+  const root = new SdkObject(fakeParent);
+  root.guid = "";
+  return root;
+}
 function createInstrumentation() {
-  const listeners = new Map();
+  const listeners = /* @__PURE__ */ new Map();
   return new Proxy({}, {
     get: (obj, prop) => {
-      if (typeof prop !== 'string') return obj[prop];
-      if (prop === 'addListener') return (listener, context) => listeners.set(listener, context);
-      if (prop === 'removeListener') return listener => listeners.delete(listener);
-      if (!prop.startsWith('on')) return obj[prop];
+      if (typeof prop !== "string")
+        return obj[prop];
+      if (prop === "addListener")
+        return (listener, context) => listeners.set(listener, context);
+      if (prop === "removeListener")
+        return (listener) => listeners.delete(listener);
+      if (!prop.startsWith("on"))
+        return obj[prop];
       return async (sdkObject, ...params) => {
         for (const [listener, context] of listeners) {
-          var _prop, _ref;
-          if (!context || sdkObject.attribution.context === context) await ((_prop = (_ref = listener)[prop]) === null || _prop === void 0 ? void 0 : _prop.call(_ref, sdkObject, ...params));
+          if (!context || sdkObject.attribution.context === context)
+            await listener[prop]?.(sdkObject, ...params);
         }
       };
     }
@@ -58,13 +64,20 @@ function createInstrumentation() {
 }
 function serverSideCallMetadata() {
   return {
-    id: '',
+    id: "",
     startTime: 0,
     endTime: 0,
-    type: 'Internal',
-    method: '',
+    type: "Internal",
+    method: "",
     params: {},
     log: [],
     isServerSide: true
   };
-}
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SdkObject,
+  createInstrumentation,
+  createRootSdkObject,
+  serverSideCallMetadata
+});