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

package/lib/server/dispatchers/electronDispatcher.js

@@ -1,93 +1,89 @@
 "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 electronDispatcher_exports = {};
+__export(electronDispatcher_exports, {
+  ElectronApplicationDispatcher: () => ElectronApplicationDispatcher,
+  ElectronDispatcher: () => ElectronDispatcher
 });
-exports.ElectronDispatcher = exports.ElectronApplicationDispatcher = void 0;
-var _browserContextDispatcher = require("./browserContextDispatcher");
-var _dispatcher = require("./dispatcher");
-var _elementHandlerDispatcher = require("./elementHandlerDispatcher");
-var _jsHandleDispatcher = require("./jsHandleDispatcher");
-var _electron = require("../electron/electron");
-/**
- * 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 ElectronDispatcher extends _dispatcher.Dispatcher {
-  constructor(scope, electron) {
-    super(scope, electron, 'Electron', {});
+module.exports = __toCommonJS(electronDispatcher_exports);
+var import_browserContextDispatcher = require("./browserContextDispatcher");
+var import_dispatcher = require("./dispatcher");
+var import_jsHandleDispatcher = require("./jsHandleDispatcher");
+var import_electron = require("../electron/electron");
+class ElectronDispatcher extends import_dispatcher.Dispatcher {
+  constructor(scope, electron, denyLaunch) {
+    super(scope, electron, "Electron", {});
     this._type_Electron = true;
+    this._denyLaunch = denyLaunch;
   }
-  async launch(params) {
-    const electronApplication = await this._object.launch(params);
-    return {
-      electronApplication: new ElectronApplicationDispatcher(this, electronApplication)
-    };
+  async launch(params, progress) {
+    if (this._denyLaunch)
+      throw new Error(`Launching more browsers is not allowed.`);
+    const electronApplication = await this._object.launch(progress, params);
+    return { electronApplication: new ElectronApplicationDispatcher(this, electronApplication) };
   }
 }
-exports.ElectronDispatcher = ElectronDispatcher;
-class ElectronApplicationDispatcher extends _dispatcher.Dispatcher {
+class ElectronApplicationDispatcher extends import_dispatcher.Dispatcher {
   constructor(scope, electronApplication) {
-    super(scope, electronApplication, 'ElectronApplication', {
-      context: new _browserContextDispatcher.BrowserContextDispatcher(scope, electronApplication.context())
+    super(scope, electronApplication, "ElectronApplication", {
+      context: import_browserContextDispatcher.BrowserContextDispatcher.from(scope, electronApplication.context())
     });
     this._type_EventTarget = true;
     this._type_ElectronApplication = true;
-    this._subscriptions = new Set();
-    this.addObjectListener(_electron.ElectronApplication.Events.Close, () => {
-      this._dispatchEvent('close');
+    this._subscriptions = /* @__PURE__ */ new Set();
+    this.addObjectListener(import_electron.ElectronApplication.Events.Close, () => {
+      this._dispatchEvent("close");
       this._dispose();
     });
-    this.addObjectListener(_electron.ElectronApplication.Events.Console, message => {
-      if (!this._subscriptions.has('console')) return;
-      this._dispatchEvent('console', {
+    this.addObjectListener(import_electron.ElectronApplication.Events.Console, (message) => {
+      if (!this._subscriptions.has("console"))
+        return;
+      this._dispatchEvent("console", {
         type: message.type(),
         text: message.text(),
-        args: message.args().map(a => _elementHandlerDispatcher.ElementHandleDispatcher.fromJSHandle(this, a)),
+        args: message.args().map((a) => import_jsHandleDispatcher.JSHandleDispatcher.fromJSHandle(this, a)),
         location: message.location()
       });
     });
   }
-  async browserWindow(params) {
-    const handle = await this._object.browserWindow(params.page.page());
-    return {
-      handle: _elementHandlerDispatcher.ElementHandleDispatcher.fromJSHandle(this, handle)
-    };
-  }
-  async evaluateExpression(params) {
-    const handle = await this._object._nodeElectronHandlePromise;
-    return {
-      value: (0, _jsHandleDispatcher.serializeResult)(await handle.evaluateExpression(params.expression, {
-        isFunction: params.isFunction
-      }, (0, _jsHandleDispatcher.parseArgument)(params.arg)))
-    };
+  async browserWindow(params, progress) {
+    const handle = await progress.race(this._object.browserWindow(params.page.page()));
+    return { handle: import_jsHandleDispatcher.JSHandleDispatcher.fromJSHandle(this, handle) };
   }
-  async evaluateExpressionHandle(params) {
-    const handle = await this._object._nodeElectronHandlePromise;
-    const result = await handle.evaluateExpressionHandle(params.expression, {
-      isFunction: params.isFunction
-    }, (0, _jsHandleDispatcher.parseArgument)(params.arg));
-    return {
-      handle: _elementHandlerDispatcher.ElementHandleDispatcher.fromJSHandle(this, result)
-    };
+  async evaluateExpression(params, progress) {
+    const handle = await progress.race(this._object._nodeElectronHandlePromise);
+    return { value: (0, import_jsHandleDispatcher.serializeResult)(await progress.race(handle.evaluateExpression(params.expression, { isFunction: params.isFunction }, (0, import_jsHandleDispatcher.parseArgument)(params.arg)))) };
   }
-  async updateSubscription(params) {
-    if (params.enabled) this._subscriptions.add(params.event);else this._subscriptions.delete(params.event);
+  async evaluateExpressionHandle(params, progress) {
+    const handle = await progress.race(this._object._nodeElectronHandlePromise);
+    const result = await progress.race(handle.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction }, (0, import_jsHandleDispatcher.parseArgument)(params.arg)));
+    return { handle: import_jsHandleDispatcher.JSHandleDispatcher.fromJSHandle(this, result) };
   }
-  async close() {
-    await this._object.close();
+  async updateSubscription(params, progress) {
+    if (params.enabled)
+      this._subscriptions.add(params.event);
+    else
+      this._subscriptions.delete(params.event);
   }
 }
-exports.ElectronApplicationDispatcher = ElectronApplicationDispatcher;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ElectronApplicationDispatcher,
+  ElectronDispatcher
+});

package/lib/server/dispatchers/elementHandlerDispatcher.js

@@ -1,233 +1,181 @@
 "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 elementHandlerDispatcher_exports = {};
+__export(elementHandlerDispatcher_exports, {
+  ElementHandleDispatcher: () => ElementHandleDispatcher
 });
-exports.ElementHandleDispatcher = void 0;
-var _browserContextDispatcher = require("./browserContextDispatcher");
-var _dispatcher = require("./dispatcher");
-var _frameDispatcher = require("./frameDispatcher");
-var _jsHandleDispatcher = require("./jsHandleDispatcher");
-var _pageDispatcher = require("./pageDispatcher");
-/**
- * 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 ElementHandleDispatcher extends _jsHandleDispatcher.JSHandleDispatcher {
-  static from(scope, handle) {
-    return (0, _dispatcher.existingDispatcher)(handle) || new ElementHandleDispatcher(scope, handle);
-  }
-  static fromNullable(scope, handle) {
-    if (!handle) return undefined;
-    return (0, _dispatcher.existingDispatcher)(handle) || new ElementHandleDispatcher(scope, handle);
-  }
-  static fromJSHandle(scope, handle) {
-    const result = (0, _dispatcher.existingDispatcher)(handle);
-    if (result) return result;
-    return handle.asElement() ? new ElementHandleDispatcher(scope, handle.asElement()) : new _jsHandleDispatcher.JSHandleDispatcher(scope, handle);
-  }
+module.exports = __toCommonJS(elementHandlerDispatcher_exports);
+var import_browserContextDispatcher = require("./browserContextDispatcher");
+var import_frameDispatcher = require("./frameDispatcher");
+var import_jsHandleDispatcher = require("./jsHandleDispatcher");
+class ElementHandleDispatcher extends import_jsHandleDispatcher.JSHandleDispatcher {
   constructor(scope, elementHandle) {
     super(scope, elementHandle);
     this._type_ElementHandle = true;
-    this._elementHandle = void 0;
     this._elementHandle = elementHandle;
   }
-  async ownerFrame(params, metadata) {
+  static from(scope, handle) {
+    return scope.connection.existingDispatcher(handle) || new ElementHandleDispatcher(scope, handle);
+  }
+  static fromNullable(scope, handle) {
+    if (!handle)
+      return void 0;
+    return scope.connection.existingDispatcher(handle) || new ElementHandleDispatcher(scope, handle);
+  }
+  static fromJSOrElementHandle(scope, handle) {
+    const result = scope.connection.existingDispatcher(handle);
+    if (result)
+      return result;
+    const elementHandle = handle.asElement();
+    if (!elementHandle)
+      return new import_jsHandleDispatcher.JSHandleDispatcher(scope, handle);
+    return new ElementHandleDispatcher(scope, elementHandle);
+  }
+  async ownerFrame(params, progress) {
     const frame = await this._elementHandle.ownerFrame();
-    return {
-      frame: frame ? _frameDispatcher.FrameDispatcher.from(this._browserContextDispatcher(), frame) : undefined
-    };
-  }
-  async contentFrame(params, metadata) {
-    const frame = await this._elementHandle.contentFrame();
-    return {
-      frame: frame ? _frameDispatcher.FrameDispatcher.from(this._browserContextDispatcher(), frame) : undefined
-    };
-  }
-  async generateLocatorString(params, metadata) {
-    return {
-      value: await this._elementHandle.generateLocatorString()
-    };
-  }
-  async getAttribute(params, metadata) {
-    const value = await this._elementHandle.getAttribute(metadata, params.name);
-    return {
-      value: value === null ? undefined : value
-    };
-  }
-  async inputValue(params, metadata) {
-    const value = await this._elementHandle.inputValue(metadata);
-    return {
-      value
-    };
-  }
-  async textContent(params, metadata) {
-    const value = await this._elementHandle.textContent(metadata);
-    return {
-      value: value === null ? undefined : value
-    };
-  }
-  async innerText(params, metadata) {
-    return {
-      value: await this._elementHandle.innerText(metadata)
-    };
-  }
-  async innerHTML(params, metadata) {
-    return {
-      value: await this._elementHandle.innerHTML(metadata)
-    };
-  }
-  async isChecked(params, metadata) {
-    return {
-      value: await this._elementHandle.isChecked(metadata)
-    };
-  }
-  async isDisabled(params, metadata) {
-    return {
-      value: await this._elementHandle.isDisabled(metadata)
-    };
-  }
-  async isEditable(params, metadata) {
-    return {
-      value: await this._elementHandle.isEditable(metadata)
-    };
-  }
-  async isEnabled(params, metadata) {
-    return {
-      value: await this._elementHandle.isEnabled(metadata)
-    };
-  }
-  async isHidden(params, metadata) {
-    return {
-      value: await this._elementHandle.isHidden(metadata)
-    };
-  }
-  async isVisible(params, metadata) {
-    return {
-      value: await this._elementHandle.isVisible(metadata)
-    };
-  }
-  async dispatchEvent(params, metadata) {
-    await this._elementHandle.dispatchEvent(metadata, params.type, (0, _jsHandleDispatcher.parseArgument)(params.eventInit));
-  }
-  async scrollIntoViewIfNeeded(params, metadata) {
-    await this._elementHandle.scrollIntoViewIfNeeded(metadata, params);
-  }
-  async hover(params, metadata) {
-    return await this._elementHandle.hover(metadata, params);
-  }
-  async click(params, metadata) {
-    return await this._elementHandle.click(metadata, params);
-  }
-  async dblclick(params, metadata) {
-    return await this._elementHandle.dblclick(metadata, params);
-  }
-  async tap(params, metadata) {
-    return await this._elementHandle.tap(metadata, params);
-  }
-  async selectOption(params, metadata) {
-    const elements = (params.elements || []).map(e => e._elementHandle);
-    return {
-      values: await this._elementHandle.selectOption(metadata, elements, params.options || [], params)
-    };
-  }
-  async fill(params, metadata) {
-    return await this._elementHandle.fill(metadata, params.value, params);
-  }
-  async selectText(params, metadata) {
-    await this._elementHandle.selectText(metadata, params);
-  }
-  async setInputFiles(params, metadata) {
-    return await this._elementHandle.setInputFiles(metadata, params);
-  }
-  async focus(params, metadata) {
-    await this._elementHandle.focus(metadata);
-  }
-  async type(params, metadata) {
-    return await this._elementHandle.type(metadata, params.text, params);
-  }
-  async press(params, metadata) {
-    return await this._elementHandle.press(metadata, params.key, params);
-  }
-  async check(params, metadata) {
-    return await this._elementHandle.check(metadata, params);
-  }
-  async uncheck(params, metadata) {
-    return await this._elementHandle.uncheck(metadata, params);
+    return { frame: frame ? import_frameDispatcher.FrameDispatcher.from(this._browserContextDispatcher(), frame) : void 0 };
   }
-  async boundingBox(params, metadata) {
-    const value = await this._elementHandle.boundingBox();
-    return {
-      value: value || undefined
-    };
+  async contentFrame(params, progress) {
+    const frame = await progress.race(this._elementHandle.contentFrame());
+    return { frame: frame ? import_frameDispatcher.FrameDispatcher.from(this._browserContextDispatcher(), frame) : void 0 };
   }
-  async screenshot(params, metadata) {
-    const mask = (params.mask || []).map(({
-      frame,
-      selector
-    }) => ({
+  async getAttribute(params, progress) {
+    const value = await this._elementHandle.getAttribute(progress, params.name);
+    return { value: value === null ? void 0 : value };
+  }
+  async inputValue(params, progress) {
+    const value = await this._elementHandle.inputValue(progress);
+    return { value };
+  }
+  async textContent(params, progress) {
+    const value = await this._elementHandle.textContent(progress);
+    return { value: value === null ? void 0 : value };
+  }
+  async innerText(params, progress) {
+    return { value: await this._elementHandle.innerText(progress) };
+  }
+  async innerHTML(params, progress) {
+    return { value: await this._elementHandle.innerHTML(progress) };
+  }
+  async isChecked(params, progress) {
+    return { value: await this._elementHandle.isChecked(progress) };
+  }
+  async isDisabled(params, progress) {
+    return { value: await this._elementHandle.isDisabled(progress) };
+  }
+  async isEditable(params, progress) {
+    return { value: await this._elementHandle.isEditable(progress) };
+  }
+  async isEnabled(params, progress) {
+    return { value: await this._elementHandle.isEnabled(progress) };
+  }
+  async isHidden(params, progress) {
+    return { value: await this._elementHandle.isHidden(progress) };
+  }
+  async isVisible(params, progress) {
+    return { value: await this._elementHandle.isVisible(progress) };
+  }
+  async dispatchEvent(params, progress) {
+    await this._elementHandle.dispatchEvent(progress, params.type, (0, import_jsHandleDispatcher.parseArgument)(params.eventInit));
+  }
+  async scrollIntoViewIfNeeded(params, progress) {
+    await this._elementHandle.scrollIntoViewIfNeeded(progress);
+  }
+  async hover(params, progress) {
+    return await this._elementHandle.hover(progress, params);
+  }
+  async click(params, progress) {
+    return await this._elementHandle.click(progress, params);
+  }
+  async dblclick(params, progress) {
+    return await this._elementHandle.dblclick(progress, params);
+  }
+  async tap(params, progress) {
+    return await this._elementHandle.tap(progress, params);
+  }
+  async selectOption(params, progress) {
+    const elements = (params.elements || []).map((e) => e._elementHandle);
+    return { values: await this._elementHandle.selectOption(progress, elements, params.options || [], params) };
+  }
+  async fill(params, progress) {
+    return await this._elementHandle.fill(progress, params.value, params);
+  }
+  async selectText(params, progress) {
+    await this._elementHandle.selectText(progress, params);
+  }
+  async setInputFiles(params, progress) {
+    return await this._elementHandle.setInputFiles(progress, params);
+  }
+  async focus(params, progress) {
+    await this._elementHandle.focus(progress);
+  }
+  async type(params, progress) {
+    return await this._elementHandle.type(progress, params.text, params);
+  }
+  async press(params, progress) {
+    return await this._elementHandle.press(progress, params.key, params);
+  }
+  async check(params, progress) {
+    return await this._elementHandle.check(progress, params);
+  }
+  async uncheck(params, progress) {
+    return await this._elementHandle.uncheck(progress, params);
+  }
+  async boundingBox(params, progress) {
+    const value = await progress.race(this._elementHandle.boundingBox());
+    return { value: value || void 0 };
+  }
+  async screenshot(params, progress) {
+    const mask = (params.mask || []).map(({ frame, selector }) => ({
       frame: frame._object,
       selector
     }));
-    return {
-      binary: await this._elementHandle.screenshot(metadata, {
-        ...params,
-        mask
-      })
-    };
-  }
-  async querySelector(params, metadata) {
-    const handle = await this._elementHandle.querySelector(params.selector, params);
-    return {
-      element: ElementHandleDispatcher.fromNullable(this.parentScope(), handle)
-    };
-  }
-  async querySelectorAll(params, metadata) {
-    const elements = await this._elementHandle.querySelectorAll(params.selector);
-    return {
-      elements: elements.map(e => ElementHandleDispatcher.from(this.parentScope(), e))
-    };
-  }
-  async evalOnSelector(params, metadata) {
-    return {
-      value: (0, _jsHandleDispatcher.serializeResult)(await this._elementHandle.evalOnSelector(params.selector, !!params.strict, params.expression, params.isFunction, (0, _jsHandleDispatcher.parseArgument)(params.arg)))
-    };
-  }
-  async evalOnSelectorAll(params, metadata) {
-    return {
-      value: (0, _jsHandleDispatcher.serializeResult)(await this._elementHandle.evalOnSelectorAll(params.selector, params.expression, params.isFunction, (0, _jsHandleDispatcher.parseArgument)(params.arg)))
-    };
-  }
-  async waitForElementState(params, metadata) {
-    await this._elementHandle.waitForElementState(metadata, params.state, params);
-  }
-  async waitForSelector(params, metadata) {
-    return {
-      element: ElementHandleDispatcher.fromNullable(this.parentScope(), await this._elementHandle.waitForSelector(metadata, params.selector, params))
-    };
+    return { binary: await this._elementHandle.screenshot(progress, { ...params, mask }) };
+  }
+  async querySelector(params, progress) {
+    const handle = await progress.race(this._elementHandle.querySelector(params.selector, params));
+    return { element: ElementHandleDispatcher.fromNullable(this.parentScope(), handle) };
+  }
+  async querySelectorAll(params, progress) {
+    const elements = await progress.race(this._elementHandle.querySelectorAll(params.selector));
+    return { elements: elements.map((e) => ElementHandleDispatcher.from(this.parentScope(), e)) };
+  }
+  async evalOnSelector(params, progress) {
+    return { value: (0, import_jsHandleDispatcher.serializeResult)(await progress.race(this._elementHandle.evalOnSelector(params.selector, !!params.strict, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg)))) };
+  }
+  async evalOnSelectorAll(params, progress) {
+    return { value: (0, import_jsHandleDispatcher.serializeResult)(await progress.race(this._elementHandle.evalOnSelectorAll(params.selector, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg)))) };
+  }
+  async waitForElementState(params, progress) {
+    await this._elementHandle.waitForElementState(progress, params.state);
+  }
+  async waitForSelector(params, progress) {
+    return { element: ElementHandleDispatcher.fromNullable(this.parentScope(), await this._elementHandle.waitForSelector(progress, params.selector, params)) };
   }
   _browserContextDispatcher() {
-    const scope = this.parentScope();
-    if (scope instanceof _browserContextDispatcher.BrowserContextDispatcher) return scope;
-    if (scope instanceof _pageDispatcher.PageDispatcher) return scope.parentScope();
-    if (scope instanceof _pageDispatcher.WorkerDispatcher || scope instanceof _frameDispatcher.FrameDispatcher) {
-      const parentScope = scope.parentScope();
-      if (parentScope instanceof _browserContextDispatcher.BrowserContextDispatcher) return parentScope;
-      return parentScope.parentScope();
-    }
-    throw new Error('ElementHandle belongs to unexpected scope');
+    const parentScope = this.parentScope().parentScope();
+    if (parentScope instanceof import_browserContextDispatcher.BrowserContextDispatcher)
+      return parentScope;
+    return parentScope.parentScope();
   }
 }
-exports.ElementHandleDispatcher = ElementHandleDispatcher;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ElementHandleDispatcher
+});