@checkly/playwright-core 1.41.2-beta.0

package/lib/server/helper.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.helper = void 0;
+var _debugLogger = require("../utils/debugLogger");
+var _eventsHelper = require("../utils/eventsHelper");
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ * Modifications 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 MAX_LOG_LENGTH = process.env.MAX_LOG_LENGTH ? +process.env.MAX_LOG_LENGTH : Infinity;
+class Helper {
+  static completeUserURL(urlString) {
+    if (urlString.startsWith('localhost') || urlString.startsWith('127.0.0.1')) urlString = 'http://' + urlString;
+    return urlString;
+  }
+  static enclosingIntRect(rect) {
+    const x = Math.floor(rect.x + 1e-3);
+    const y = Math.floor(rect.y + 1e-3);
+    const x2 = Math.ceil(rect.x + rect.width - 1e-3);
+    const y2 = Math.ceil(rect.y + rect.height - 1e-3);
+    return {
+      x,
+      y,
+      width: x2 - x,
+      height: y2 - y
+    };
+  }
+  static enclosingIntSize(size) {
+    return {
+      width: Math.floor(size.width + 1e-3),
+      height: Math.floor(size.height + 1e-3)
+    };
+  }
+  static getViewportSizeFromWindowFeatures(features) {
+    const widthString = features.find(f => f.startsWith('width='));
+    const heightString = features.find(f => f.startsWith('height='));
+    const width = widthString ? parseInt(widthString.substring(6), 10) : NaN;
+    const height = heightString ? parseInt(heightString.substring(7), 10) : NaN;
+    if (!Number.isNaN(width) && !Number.isNaN(height)) return {
+      width,
+      height
+    };
+    return null;
+  }
+  static waitForEvent(progress, emitter, event, predicate) {
+    const listeners = [];
+    const promise = new Promise((resolve, reject) => {
+      listeners.push(_eventsHelper.eventsHelper.addEventListener(emitter, event, eventArg => {
+        try {
+          if (predicate && !predicate(eventArg)) return;
+          _eventsHelper.eventsHelper.removeEventListeners(listeners);
+          resolve(eventArg);
+        } catch (e) {
+          _eventsHelper.eventsHelper.removeEventListeners(listeners);
+          reject(e);
+        }
+      }));
+    });
+    const dispose = () => _eventsHelper.eventsHelper.removeEventListeners(listeners);
+    if (progress) progress.cleanupWhenAborted(dispose);
+    return {
+      promise,
+      dispose
+    };
+  }
+  static secondsToRoundishMillis(value) {
+    return (value * 1000000 | 0) / 1000;
+  }
+  static millisToRoundishMillis(value) {
+    return (value * 1000 | 0) / 1000;
+  }
+  static debugProtocolLogger(protocolLogger) {
+    return (direction, message) => {
+      if (protocolLogger) protocolLogger(direction, message);
+      if (_debugLogger.debugLogger.isEnabled('protocol')) {
+        let text = JSON.stringify(message);
+        if (text.length > MAX_LOG_LENGTH) text = text.substring(0, MAX_LOG_LENGTH / 2) + ' <<<<<( LOG TRUNCATED )>>>>> ' + text.substring(text.length - MAX_LOG_LENGTH / 2);
+        _debugLogger.debugLogger.log('protocol', (direction === 'send' ? 'SEND ► ' : '◀ RECV ') + text);
+      }
+    };
+  }
+  static formatBrowserLogs(logs) {
+    if (!logs.length) return '';
+    return '\n' + logs.join('\n');
+  }
+}
+const helper = exports.helper = Helper;

package/lib/server/index.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DispatcherConnection", {
+  enumerable: true,
+  get: function () {
+    return _dispatcher.DispatcherConnection;
+  }
+});
+Object.defineProperty(exports, "PlaywrightDispatcher", {
+  enumerable: true,
+  get: function () {
+    return _playwrightDispatcher.PlaywrightDispatcher;
+  }
+});
+Object.defineProperty(exports, "Registry", {
+  enumerable: true,
+  get: function () {
+    return _registry.Registry;
+  }
+});
+Object.defineProperty(exports, "RootDispatcher", {
+  enumerable: true,
+  get: function () {
+    return _dispatcher.RootDispatcher;
+  }
+});
+Object.defineProperty(exports, "SocksProxy", {
+  enumerable: true,
+  get: function () {
+    return _socksProxy.SocksProxy;
+  }
+});
+Object.defineProperty(exports, "createPlaywright", {
+  enumerable: true,
+  get: function () {
+    return _playwright.createPlaywright;
+  }
+});
+Object.defineProperty(exports, "installBrowsersForNpmInstall", {
+  enumerable: true,
+  get: function () {
+    return _registry.installBrowsersForNpmInstall;
+  }
+});
+Object.defineProperty(exports, "installDefaultBrowsersForNpmInstall", {
+  enumerable: true,
+  get: function () {
+    return _registry.installDefaultBrowsersForNpmInstall;
+  }
+});
+Object.defineProperty(exports, "openTraceInBrowser", {
+  enumerable: true,
+  get: function () {
+    return _traceViewer.openTraceInBrowser;
+  }
+});
+Object.defineProperty(exports, "openTraceViewerApp", {
+  enumerable: true,
+  get: function () {
+    return _traceViewer.openTraceViewerApp;
+  }
+});
+Object.defineProperty(exports, "registry", {
+  enumerable: true,
+  get: function () {
+    return _registry.registry;
+  }
+});
+Object.defineProperty(exports, "registryDirectory", {
+  enumerable: true,
+  get: function () {
+    return _registry.registryDirectory;
+  }
+});
+Object.defineProperty(exports, "serverSideCallMetadata", {
+  enumerable: true,
+  get: function () {
+    return _instrumentation.serverSideCallMetadata;
+  }
+});
+Object.defineProperty(exports, "writeDockerVersion", {
+  enumerable: true,
+  get: function () {
+    return _registry.writeDockerVersion;
+  }
+});
+var _registry = require("./registry");
+var _dispatcher = require("./dispatchers/dispatcher");
+var _playwrightDispatcher = require("./dispatchers/playwrightDispatcher");
+var _playwright = require("./playwright");
+var _traceViewer = require("./trace/viewer/traceViewer");
+var _instrumentation = require("./instrumentation");
+var _socksProxy = require("../common/socksProxy");

package/lib/server/input.js

@@ -0,0 +1,301 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.keypadLocation = exports.Touchscreen = exports.Mouse = exports.Keyboard = void 0;
+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 && Object.prototype.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'];
+class Keyboard {
+  constructor(raw, page) {
+    this._pressedModifiers = new Set();
+    this._pressedKeys = new Set();
+    this._raw = void 0;
+    this._page = void 0;
+    this._raw = raw;
+    this._page = page;
+  }
+  async down(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);
+    const text = description.text;
+    await this._raw.keydown(this._pressedModifiers, description.code, description.keyCode, description.keyCodeWithoutLocation, description.key, description.location, autoRepeat, text);
+  }
+  _keyDescriptionForString(keyString) {
+    let description = usKeyboardLayout.get(keyString);
+    (0, _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: ''
+    };
+    return description;
+  }
+  async up(key) {
+    const description = this._keyDescriptionForString(key);
+    if (kModifiers.includes(description.key)) this._pressedModifiers.delete(description.key);
+    this._pressedKeys.delete(description.code);
+    await this._raw.keyup(this._pressedModifiers, description.code, description.keyCode, description.keyCodeWithoutLocation, description.key, description.location);
+  }
+  async insertText(text) {
+    await this._raw.sendText(text);
+  }
+  async type(text, options) {
+    const delay = options && options.delay || undefined;
+    for (const char of text) {
+      if (usKeyboardLayout.has(char)) {
+        await this.press(char, {
+          delay
+        });
+      } else {
+        if (delay) await new Promise(f => setTimeout(f, delay));
+        await this.insertText(char);
+      }
+    }
+  }
+  async press(key, options = {}) {
+    function split(keyString) {
+      const keys = [];
+      let building = '';
+      for (const char of keyString) {
+        if (char === '+' && building) {
+          keys.push(building);
+          building = '';
+        } else {
+          building += char;
+        }
+      }
+      keys.push(building);
+      return keys;
+    }
+    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]);
+  }
+  async _ensureModifiers(modifiers) {
+    for (const modifier of modifiers) {
+      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);
+    }
+    return restore;
+  }
+  _modifiers() {
+    return this._pressedModifiers;
+  }
+}
+exports.Keyboard = Keyboard;
+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._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;
+    const fromX = this._x;
+    const fromY = this._y;
+    this._x = x;
+    this._y = y;
+    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);
+    }
+  }
+  async down(options = {}, metadata) {
+    if (metadata) metadata.point = {
+      x: this._x,
+      y: this._y
+    };
+    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);
+  }
+  async up(options = {}, metadata) {
+    if (metadata) metadata.point = {
+      x: this._x,
+      y: this._y
+    };
+    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);
+  }
+  async click(x, y, options = {}, metadata) {
+    if (metadata) metadata.point = {
+      x: this._x,
+      y: this._y
+    };
+    const {
+      delay = null,
+      clickCount = 1
+    } = options;
+    if (delay) {
+      this.move(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));
+      }
+    } else {
+      const promises = [];
+      promises.push(this.move(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
+        }));
+      }
+      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);
+  }
+}
+exports.Mouse = Mouse;
+const aliases = 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();
+  for (const code in layout) {
+    const definition = layout[code];
+    const description = {
+      key: definition.key || '',
+      keyCode: definition.keyCode || 0,
+      keyCodeWithoutLocation: definition.keyCodeWithoutLocation || definition.keyCode || 0,
+      code,
+      text: definition.text || '',
+      location: definition.location || 0
+    };
+    if (definition.key.length === 1) description.text = description.key;
+
+    // Generate shifted definition.
+    let shiftedDescription;
+    if (definition.shiftKey) {
+      (0, _utils.assert)(definition.shiftKey.length === 1);
+      shiftedDescription = {
+        ...description
+      };
+      shiftedDescription.key = definition.shiftKey;
+      shiftedDescription.text = definition.shiftKey;
+      if (definition.shiftKeyCode) shiftedDescription.keyCode = definition.shiftKeyCode;
+    }
+
+    // Map from code: Digit3 -> { ... descrption, shifted }
+    result.set(code, {
+      ...description,
+      shifted: shiftedDescription
+    });
+
+    // Map from aliases: Shift -> non-shiftable definition
+    if (aliases.has(code)) {
+      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
+    });
+  }
+  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());
+  }
+}
+exports.Touchscreen = Touchscreen;

package/lib/server/instrumentation.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SdkObject = void 0;
+exports.createInstrumentation = createInstrumentation;
+exports.kTestSdkObjects = void 0;
+exports.serverSideCallMetadata = serverSideCallMetadata;
+var _events = require("events");
+var _utils = require("../utils");
+/**
+ * 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.
+ */
+
+const kTestSdkObjects = exports.kTestSdkObjects = new WeakSet();
+class SdkObject extends _events.EventEmitter {
+  constructor(parent, guidPrefix, guid) {
+    super();
+    this.guid = void 0;
+    this.attribution = void 0;
+    this.instrumentation = void 0;
+    this.guid = guid || `${guidPrefix || ''}@${(0, _utils.createGuid)()}`;
+    this.setMaxListeners(0);
+    this.attribution = {
+      ...parent.attribution
+    };
+    this.instrumentation = parent.instrumentation;
+    if (process.env._PW_INTERNAL_COUNT_SDK_OBJECTS) kTestSdkObjects.add(this);
+  }
+}
+exports.SdkObject = SdkObject;
+function createInstrumentation() {
+  const listeners = 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];
+      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));
+        }
+      };
+    }
+  });
+}
+function serverSideCallMetadata() {
+  return {
+    id: '',
+    startTime: 0,
+    endTime: 0,
+    wallTime: Date.now(),
+    type: 'Internal',
+    method: '',
+    params: {},
+    log: [],
+    isServerSide: true
+  };
+}