rebrowser-playwright-core 1.49.1 → 1.52.0

package/lib/server/dispatchers/electronDispatcher.js

@@ -1,93 +1,90 @@
 "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 _dispatcher = require("./dispatcher");
-var _electron = require("../electron/electron");
-var _browserContextDispatcher = require("./browserContextDispatcher");
-var _jsHandleDispatcher = require("./jsHandleDispatcher");
-var _elementHandlerDispatcher = require("./elementHandlerDispatcher");
-/**
- * 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 {
+module.exports = __toCommonJS(electronDispatcher_exports);
+var import_browserContextDispatcher = require("./browserContextDispatcher");
+var import_dispatcher = require("./dispatcher");
+var import_elementHandlerDispatcher = require("./elementHandlerDispatcher");
+var import_jsHandleDispatcher = require("./jsHandleDispatcher");
+var import_electron = require("../electron/electron");
+class ElectronDispatcher extends import_dispatcher.Dispatcher {
   constructor(scope, electron) {
-    super(scope, electron, 'Electron', {});
+    super(scope, electron, "Electron", {});
     this._type_Electron = true;
   }
   async launch(params) {
     const electronApplication = await this._object.launch(params);
-    return {
-      electronApplication: new ElectronApplicationDispatcher(this, electronApplication)
-    };
+    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: new import_browserContextDispatcher.BrowserContextDispatcher(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_elementHandlerDispatcher.ElementHandleDispatcher.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)
-    };
+    return { handle: import_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)))
-    };
+    return { value: (0, import_jsHandleDispatcher.serializeResult)(await handle.evaluateExpression(params.expression, { isFunction: params.isFunction }, (0, import_jsHandleDispatcher.parseArgument)(params.arg))) };
   }
   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)
-    };
+    const result = await handle.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction }, (0, import_jsHandleDispatcher.parseArgument)(params.arg));
+    return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSHandle(this, result) };
   }
   async updateSubscription(params) {
-    if (params.enabled) this._subscriptions.add(params.event);else this._subscriptions.delete(params.event);
+    if (params.enabled)
+      this._subscriptions.add(params.event);
+    else
+      this._subscriptions.delete(params.event);
   }
   async close() {
     await this._object.close();
   }
 }
-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,121 +1,100 @@
 "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 _dispatcher = require("./dispatcher");
-var _jsHandleDispatcher = require("./jsHandleDispatcher");
-var _frameDispatcher = require("./frameDispatcher");
-var _browserContextDispatcher = require("./browserContextDispatcher");
-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 {
+module.exports = __toCommonJS(elementHandlerDispatcher_exports);
+var import_browserContextDispatcher = require("./browserContextDispatcher");
+var import_dispatcher = require("./dispatcher");
+var import_frameDispatcher = require("./frameDispatcher");
+var import_jsHandleDispatcher = require("./jsHandleDispatcher");
+var import_pageDispatcher = require("./pageDispatcher");
+class ElementHandleDispatcher extends import_jsHandleDispatcher.JSHandleDispatcher {
+  constructor(scope, elementHandle) {
+    super(scope, elementHandle);
+    this._type_ElementHandle = true;
+    this._elementHandle = elementHandle;
+  }
   static from(scope, handle) {
-    return (0, _dispatcher.existingDispatcher)(handle) || new ElementHandleDispatcher(scope, handle);
+    return (0, import_dispatcher.existingDispatcher)(handle) || new ElementHandleDispatcher(scope, handle);
   }
   static fromNullable(scope, handle) {
-    if (!handle) return undefined;
-    return (0, _dispatcher.existingDispatcher)(handle) || new ElementHandleDispatcher(scope, handle);
+    if (!handle)
+      return void 0;
+    return (0, import_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);
-  }
-  constructor(scope, elementHandle) {
-    super(scope, elementHandle);
-    this._type_ElementHandle = true;
-    this._elementHandle = void 0;
-    this._elementHandle = elementHandle;
+    const result = (0, import_dispatcher.existingDispatcher)(handle);
+    if (result)
+      return result;
+    return handle.asElement() ? new ElementHandleDispatcher(scope, handle.asElement()) : new import_jsHandleDispatcher.JSHandleDispatcher(scope, handle);
   }
   async ownerFrame(params, metadata) {
     const frame = await this._elementHandle.ownerFrame();
-    return {
-      frame: frame ? _frameDispatcher.FrameDispatcher.from(this._browserContextDispatcher(), frame) : undefined
-    };
+    return { frame: frame ? import_frameDispatcher.FrameDispatcher.from(this._browserContextDispatcher(), frame) : void 0 };
   }
   async contentFrame(params, metadata) {
     const frame = await this._elementHandle.contentFrame();
-    return {
-      frame: frame ? _frameDispatcher.FrameDispatcher.from(this._browserContextDispatcher(), frame) : undefined
-    };
+    return { frame: frame ? import_frameDispatcher.FrameDispatcher.from(this._browserContextDispatcher(), frame) : void 0 };
+  }
+  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
-    };
+    return { value: value === null ? void 0 : value };
   }
   async inputValue(params, metadata) {
     const value = await this._elementHandle.inputValue(metadata);
-    return {
-      value
-    };
+    return { value };
   }
   async textContent(params, metadata) {
     const value = await this._elementHandle.textContent(metadata);
-    return {
-      value: value === null ? undefined : value
-    };
+    return { value: value === null ? void 0 : value };
   }
   async innerText(params, metadata) {
-    return {
-      value: await this._elementHandle.innerText(metadata)
-    };
+    return { value: await this._elementHandle.innerText(metadata) };
   }
   async innerHTML(params, metadata) {
-    return {
-      value: await this._elementHandle.innerHTML(metadata)
-    };
+    return { value: await this._elementHandle.innerHTML(metadata) };
   }
   async isChecked(params, metadata) {
-    return {
-      value: await this._elementHandle.isChecked(metadata)
-    };
+    return { value: await this._elementHandle.isChecked(metadata) };
   }
   async isDisabled(params, metadata) {
-    return {
-      value: await this._elementHandle.isDisabled(metadata)
-    };
+    return { value: await this._elementHandle.isDisabled(metadata) };
   }
   async isEditable(params, metadata) {
-    return {
-      value: await this._elementHandle.isEditable(metadata)
-    };
+    return { value: await this._elementHandle.isEditable(metadata) };
   }
   async isEnabled(params, metadata) {
-    return {
-      value: await this._elementHandle.isEnabled(metadata)
-    };
+    return { value: await this._elementHandle.isEnabled(metadata) };
   }
   async isHidden(params, metadata) {
-    return {
-      value: await this._elementHandle.isHidden(metadata)
-    };
+    return { value: await this._elementHandle.isHidden(metadata) };
   }
   async isVisible(params, metadata) {
-    return {
-      value: await this._elementHandle.isVisible(metadata)
-    };
+    return { value: await this._elementHandle.isVisible(metadata) };
   }
   async dispatchEvent(params, metadata) {
-    await this._elementHandle.dispatchEvent(metadata, params.type, (0, _jsHandleDispatcher.parseArgument)(params.eventInit));
+    await this._elementHandle.dispatchEvent(metadata, params.type, (0, import_jsHandleDispatcher.parseArgument)(params.eventInit));
   }
   async scrollIntoViewIfNeeded(params, metadata) {
     await this._elementHandle.scrollIntoViewIfNeeded(metadata, params);
@@ -133,10 +112,8 @@ class ElementHandleDispatcher extends _jsHandleDispatcher.JSHandleDispatcher {
     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)
-    };
+    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);
@@ -164,65 +141,51 @@ class ElementHandleDispatcher extends _jsHandleDispatcher.JSHandleDispatcher {
   }
   async boundingBox(params, metadata) {
     const value = await this._elementHandle.boundingBox();
-    return {
-      value: value || undefined
-    };
+    return { value: value || void 0 };
   }
   async screenshot(params, metadata) {
-    const mask = (params.mask || []).map(({
-      frame,
-      selector
-    }) => ({
+    const mask = (params.mask || []).map(({ frame, selector }) => ({
       frame: frame._object,
       selector
     }));
-    return {
-      binary: await this._elementHandle.screenshot(metadata, {
-        ...params,
-        mask
-      })
-    };
+    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)
-    };
+    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))
-    };
+    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)))
-    };
+    return { value: (0, import_jsHandleDispatcher.serializeResult)(await this._elementHandle.evalOnSelector(params.selector, !!params.strict, params.expression, params.isFunction, (0, import_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)))
-    };
+    return { value: (0, import_jsHandleDispatcher.serializeResult)(await this._elementHandle.evalOnSelectorAll(params.selector, params.expression, params.isFunction, (0, import_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 { element: ElementHandleDispatcher.fromNullable(this.parentScope(), await this._elementHandle.waitForSelector(metadata, 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) {
+    if (scope instanceof import_browserContextDispatcher.BrowserContextDispatcher)
+      return scope;
+    if (scope instanceof import_pageDispatcher.PageDispatcher)
+      return scope.parentScope();
+    if (scope instanceof import_pageDispatcher.WorkerDispatcher || scope instanceof import_frameDispatcher.FrameDispatcher) {
       const parentScope = scope.parentScope();
-      if (parentScope instanceof _browserContextDispatcher.BrowserContextDispatcher) return parentScope;
+      if (parentScope instanceof import_browserContextDispatcher.BrowserContextDispatcher)
+        return parentScope;
       return parentScope.parentScope();
     }
-    throw new Error('ElementHandle belongs to unexpected scope');
+    throw new Error("ElementHandle belongs to unexpected scope");
   }
 }
-exports.ElementHandleDispatcher = ElementHandleDispatcher;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ElementHandleDispatcher
+});