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

package/lib/server/recorder/recorderInTraceViewer.js

@@ -1,144 +1,115 @@
 "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 recorderInTraceViewer_exports = {};
+__export(recorderInTraceViewer_exports, {
+  RecorderInTraceViewer: () => RecorderInTraceViewer
 });
-exports.RecorderInTraceViewer = void 0;
-var _path = _interopRequireDefault(require("path"));
-var _events = require("events");
-var _traceViewer = require("../trace/viewer/traceViewer");
-var _manualPromise = require("../../utils/manualPromise");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-/**
- * 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 RecorderInTraceViewer extends _events.EventEmitter {
+module.exports = __toCommonJS(recorderInTraceViewer_exports);
+var import_path = __toESM(require("path"));
+var import_events = require("events");
+var import_traceViewer = require("../trace/viewer/traceViewer");
+var import_manualPromise = require("../../utils/manualPromise");
+class RecorderInTraceViewer extends import_events.EventEmitter {
   static factory(context) {
-    return async recorder => {
+    return async (recorder) => {
       const transport = new RecorderTransport();
-      const trace = _path.default.join(context._browser.options.tracesDir, 'trace');
-      const {
-        wsEndpointForTest,
-        tracePage,
-        traceServer
-      } = await openApp(trace, {
-        transport,
-        headless: !context._browser.options.headful
-      });
+      const trace = import_path.default.join(context._browser.options.tracesDir, "trace");
+      const { wsEndpointForTest, tracePage, traceServer } = await openApp(trace, { transport, headless: !context._browser.options.headful });
       return new RecorderInTraceViewer(transport, tracePage, traceServer, wsEndpointForTest);
     };
   }
   constructor(transport, tracePage, traceServer, wsEndpointForTest) {
     super();
-    this.wsEndpointForTest = void 0;
-    this._transport = void 0;
-    this._tracePage = void 0;
-    this._traceServer = void 0;
     this._transport = transport;
     this._transport.eventSink.resolve(this);
     this._tracePage = tracePage;
     this._traceServer = traceServer;
     this.wsEndpointForTest = wsEndpointForTest;
-    this._tracePage.once('close', () => {
+    this._tracePage.once("close", () => {
       this.close();
     });
   }
   async close() {
-    await this._tracePage.context().close({
-      reason: 'Recorder window closed'
-    });
+    await this._tracePage.context().close({ reason: "Recorder window closed" });
     await this._traceServer.stop();
   }
   async setPaused(paused) {
-    this._transport.deliverEvent('setPaused', {
-      paused
-    });
+    this._transport.deliverEvent("setPaused", { paused });
   }
   async setMode(mode) {
-    this._transport.deliverEvent('setMode', {
-      mode
-    });
+    this._transport.deliverEvent("setMode", { mode });
   }
   async setRunningFile(file) {
-    this._transport.deliverEvent('setRunningFile', {
-      file
-    });
+    this._transport.deliverEvent("setRunningFile", { file });
   }
   async setSelector(selector, userGesture) {
-    this._transport.deliverEvent('setSelector', {
-      selector,
-      userGesture
-    });
+    this._transport.deliverEvent("setSelector", { selector, userGesture });
   }
   async updateCallLogs(callLogs) {
-    this._transport.deliverEvent('updateCallLogs', {
-      callLogs
-    });
+    this._transport.deliverEvent("updateCallLogs", { callLogs });
   }
   async setSources(sources) {
-    this._transport.deliverEvent('setSources', {
-      sources
-    });
+    this._transport.deliverEvent("setSources", { sources });
     if (process.env.PWTEST_CLI_IS_UNDER_TEST && sources.length) {
-      if (process._didSetSourcesForTest(sources[0].text)) this.close();
+      if (process._didSetSourcesForTest(sources[0].text))
+        this.close();
     }
   }
   async setActions(actions, sources) {
-    this._transport.deliverEvent('setActions', {
-      actions,
-      sources
-    });
+    this._transport.deliverEvent("setActions", { actions, sources });
   }
 }
-exports.RecorderInTraceViewer = RecorderInTraceViewer;
 async function openApp(trace, options) {
-  const traceServer = await (0, _traceViewer.startTraceViewerServer)(options);
-  await (0, _traceViewer.installRootRedirect)(traceServer, [trace], {
-    ...options,
-    webApp: 'recorder.html'
-  });
-  const page = await (0, _traceViewer.openTraceViewerApp)(traceServer.urlPrefix('precise'), 'chromium', options);
-  return {
-    wsEndpointForTest: page.context()._browser.options.wsEndpoint,
-    tracePage: page,
-    traceServer
-  };
+  const traceServer = await (0, import_traceViewer.startTraceViewerServer)(options);
+  await (0, import_traceViewer.installRootRedirect)(traceServer, [trace], { ...options, webApp: "recorder.html" });
+  const page = await (0, import_traceViewer.openTraceViewerApp)(traceServer.urlPrefix("precise"), "chromium", options);
+  return { wsEndpointForTest: page.context()._browser.options.wsEndpoint, tracePage: page, traceServer };
 }
 class RecorderTransport {
   constructor() {
-    this._connected = new _manualPromise.ManualPromise();
-    this.eventSink = new _manualPromise.ManualPromise();
-    this.sendEvent = void 0;
-    this.close = void 0;
+    this._connected = new import_manualPromise.ManualPromise();
+    this.eventSink = new import_manualPromise.ManualPromise();
   }
   onconnect() {
     this._connected.resolve();
   }
   async dispatch(method, params) {
     const eventSink = await this.eventSink;
-    eventSink.emit('event', {
-      event: method,
-      params
-    });
+    eventSink.emit("event", { event: method, params });
+  }
+  onclose() {
   }
-  onclose() {}
   deliverEvent(method, params) {
-    this._connected.then(() => {
-      var _this$sendEvent;
-      return (_this$sendEvent = this.sendEvent) === null || _this$sendEvent === void 0 ? void 0 : _this$sendEvent.call(this, method, params);
-    });
+    this._connected.then(() => this.sendEvent?.(method, params));
   }
-}
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RecorderInTraceViewer
+});

package/lib/server/recorder/recorderRunner.js

@@ -1,159 +1,136 @@
 "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 recorderRunner_exports = {};
+__export(recorderRunner_exports, {
+  performAction: () => performAction,
+  toClickOptions: () => toClickOptions
 });
-exports.performAction = performAction;
-exports.toClickOptions = toClickOptions;
-var _utils = require("../../utils");
-var _language = require("../codegen/language");
-var _instrumentation = require("../instrumentation");
-var _recorderUtils = require("./recorderUtils");
-/**
- * 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(recorderRunner_exports);
+var import_utils = require("../../utils");
+var import_language = require("../codegen/language");
+var import_instrumentation = require("../instrumentation");
+var import_recorderUtils = require("./recorderUtils");
+var import_progress = require("../progress");
 async function performAction(pageAliases, actionInContext) {
-  const callMetadata = (0, _instrumentation.serverSideCallMetadata)();
-  const mainFrame = (0, _recorderUtils.mainFrameForAction)(pageAliases, actionInContext);
-  const {
-    action
-  } = actionInContext;
-  const kActionTimeout = 5000;
-  if (action.name === 'navigate') {
-    await mainFrame.goto(callMetadata, action.url, {
-      timeout: kActionTimeout
-    });
+  const callMetadata = (0, import_instrumentation.serverSideCallMetadata)();
+  const mainFrame = (0, import_recorderUtils.mainFrameForAction)(pageAliases, actionInContext);
+  const controller = new import_progress.ProgressController(callMetadata, mainFrame);
+  const kActionTimeout = 5e3;
+  return await controller.run((progress) => performActionImpl(progress, mainFrame, actionInContext), kActionTimeout);
+}
+async function performActionImpl(progress, mainFrame, actionInContext) {
+  const { action } = actionInContext;
+  if (action.name === "navigate") {
+    await mainFrame.goto(progress, action.url);
     return;
   }
-  if (action.name === 'openPage') throw Error('Not reached');
-  if (action.name === 'closePage') {
-    await mainFrame._page.close(callMetadata);
+  if (action.name === "openPage")
+    throw Error("Not reached");
+  if (action.name === "closePage") {
+    await mainFrame._page.close();
     return;
   }
-  const selector = (0, _recorderUtils.buildFullSelector)(actionInContext.frame.framePath, action.selector);
-  if (action.name === 'click') {
+  const selector = (0, import_recorderUtils.buildFullSelector)(actionInContext.frame.framePath, action.selector);
+  if (action.name === "click") {
     const options = toClickOptions(action);
-    await mainFrame.click(callMetadata, selector, {
-      ...options,
-      timeout: kActionTimeout,
-      strict: true
-    });
+    await mainFrame.click(progress, selector, { ...options, strict: true });
     return;
   }
-  if (action.name === 'press') {
-    const modifiers = (0, _language.toKeyboardModifiers)(action.modifiers);
-    const shortcut = [...modifiers, action.key].join('+');
-    await mainFrame.press(callMetadata, selector, shortcut, {
-      timeout: kActionTimeout,
-      strict: true
-    });
+  if (action.name === "press") {
+    const modifiers = (0, import_language.toKeyboardModifiers)(action.modifiers);
+    const shortcut = [...modifiers, action.key].join("+");
+    await mainFrame.press(progress, selector, shortcut, { strict: true });
     return;
   }
-  if (action.name === 'fill') {
-    await mainFrame.fill(callMetadata, selector, action.text, {
-      timeout: kActionTimeout,
-      strict: true
-    });
+  if (action.name === "fill") {
+    await mainFrame.fill(progress, selector, action.text, { strict: true });
     return;
   }
-  if (action.name === 'setInputFiles') {
-    await mainFrame.setInputFiles(callMetadata, selector, {
-      selector,
-      payloads: [],
-      timeout: kActionTimeout,
-      strict: true
-    });
+  if (action.name === "setInputFiles") {
+    await mainFrame.setInputFiles(progress, selector, { selector, payloads: [], strict: true });
     return;
   }
-  if (action.name === 'check') {
-    await mainFrame.check(callMetadata, selector, {
-      timeout: kActionTimeout,
-      strict: true
-    });
+  if (action.name === "check") {
+    await mainFrame.check(progress, selector, { strict: true });
     return;
   }
-  if (action.name === 'uncheck') {
-    await mainFrame.uncheck(callMetadata, selector, {
-      timeout: kActionTimeout,
-      strict: true
-    });
+  if (action.name === "uncheck") {
+    await mainFrame.uncheck(progress, selector, { strict: true });
     return;
   }
-  if (action.name === 'select') {
-    const values = action.options.map(value => ({
-      value
-    }));
-    await mainFrame.selectOption(callMetadata, selector, [], values, {
-      timeout: kActionTimeout,
-      strict: true
-    });
+  if (action.name === "select") {
+    const values = action.options.map((value) => ({ value }));
+    await mainFrame.selectOption(progress, selector, [], values, { strict: true });
     return;
   }
-  if (action.name === 'assertChecked') {
-    await mainFrame.expect(callMetadata, selector, {
+  if (action.name === "assertChecked") {
+    await mainFrame.expect(progress, selector, {
       selector,
-      expression: 'to.be.checked',
-      expectedValue: {
-        checked: action.checked
-      },
-      isNot: !action.checked,
-      timeout: kActionTimeout
+      expression: "to.be.checked",
+      expectedValue: { checked: action.checked },
+      isNot: !action.checked
     });
     return;
   }
-  if (action.name === 'assertText') {
-    await mainFrame.expect(callMetadata, selector, {
+  if (action.name === "assertText") {
+    await mainFrame.expect(progress, selector, {
       selector,
-      expression: 'to.have.text',
-      expectedText: (0, _utils.serializeExpectedTextValues)([action.text], {
-        matchSubstring: true,
-        normalizeWhiteSpace: true
-      }),
-      isNot: false,
-      timeout: kActionTimeout
+      expression: "to.have.text",
+      expectedText: (0, import_utils.serializeExpectedTextValues)([action.text], { matchSubstring: true, normalizeWhiteSpace: true }),
+      isNot: false
     });
     return;
   }
-  if (action.name === 'assertValue') {
-    await mainFrame.expect(callMetadata, selector, {
+  if (action.name === "assertValue") {
+    await mainFrame.expect(progress, selector, {
       selector,
-      expression: 'to.have.value',
+      expression: "to.have.value",
       expectedValue: action.value,
-      isNot: false,
-      timeout: kActionTimeout
+      isNot: false
     });
     return;
   }
-  if (action.name === 'assertVisible') {
-    await mainFrame.expect(callMetadata, selector, {
+  if (action.name === "assertVisible") {
+    await mainFrame.expect(progress, selector, {
       selector,
-      expression: 'to.be.visible',
-      isNot: false,
-      timeout: kActionTimeout
+      expression: "to.be.visible",
+      isNot: false
     });
     return;
   }
-  throw new Error('Internal error: unexpected action ' + action.name);
+  throw new Error("Internal error: unexpected action " + action.name);
 }
 function toClickOptions(action) {
-  const modifiers = (0, _language.toKeyboardModifiers)(action.modifiers);
+  const modifiers = (0, import_language.toKeyboardModifiers)(action.modifiers);
   const options = {};
-  if (action.button !== 'left') options.button = action.button;
-  if (modifiers.length) options.modifiers = modifiers;
-  if (action.clickCount > 1) options.clickCount = action.clickCount;
-  if (action.position) options.position = action.position;
+  if (action.button !== "left")
+    options.button = action.button;
+  if (modifiers.length)
+    options.modifiers = modifiers;
+  if (action.clickCount > 1)
+    options.clickCount = action.clickCount;
+  if (action.position)
+    options.position = action.position;
   return options;
-}
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  performAction,
+  toClickOptions
+});

package/lib/server/recorder/recorderSignalProcessor.js

@@ -0,0 +1,83 @@
+"use strict";
+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 recorderSignalProcessor_exports = {};
+__export(recorderSignalProcessor_exports, {
+  RecorderSignalProcessor: () => RecorderSignalProcessor
+});
+module.exports = __toCommonJS(recorderSignalProcessor_exports);
+var import_debug = require("../utils/debug");
+var import_time = require("../../utils/isomorphic/time");
+var import_recorderUtils = require("./recorderUtils");
+class RecorderSignalProcessor {
+  constructor(actionSink) {
+    this._lastAction = null;
+    this._delegate = actionSink;
+  }
+  addAction(actionInContext) {
+    this._lastAction = actionInContext;
+    this._delegate.addAction(actionInContext);
+  }
+  signal(pageAlias, frame, signal) {
+    const timestamp = (0, import_time.monotonicTime)();
+    if (signal.name === "navigation" && frame._page.mainFrame() === frame) {
+      const lastAction = this._lastAction;
+      const signalThreshold = (0, import_debug.isUnderTest)() ? 500 : 5e3;
+      let generateGoto = false;
+      if (!lastAction)
+        generateGoto = true;
+      else if (lastAction.action.name !== "click" && lastAction.action.name !== "press" && lastAction.action.name !== "fill")
+        generateGoto = true;
+      else if (timestamp - lastAction.startTime > signalThreshold)
+        generateGoto = true;
+      if (generateGoto) {
+        this.addAction({
+          frame: {
+            pageGuid: frame._page.guid,
+            pageAlias,
+            framePath: []
+          },
+          action: {
+            name: "navigate",
+            url: frame.url(),
+            signals: []
+          },
+          startTime: timestamp,
+          endTime: timestamp
+        });
+      }
+      return;
+    }
+    (0, import_recorderUtils.generateFrameSelector)(frame).then((framePath) => {
+      const signalInContext = {
+        frame: {
+          pageGuid: frame._page.guid,
+          pageAlias,
+          framePath
+        },
+        signal,
+        timestamp
+      };
+      this._delegate.addSignal(signalInContext);
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RecorderSignalProcessor
+});