patchright-core 1.51.2 → 1.52.0

package/lib/client/browserType.js

@@ -1,160 +1,138 @@
 "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 browserType_exports = {};
+__export(browserType_exports, {
+  BrowserType: () => BrowserType
 });
-exports.BrowserType = void 0;
-var _browser3 = require("./browser");
-var _browserContext = require("./browserContext");
-var _channelOwner = require("./channelOwner");
-var _clientHelper = require("./clientHelper");
-var _events = require("./events");
-var _assert = require("../utils/isomorphic/assert");
-var _headers = require("../utils/isomorphic/headers");
-var _time = require("../utils/isomorphic/time");
-var _timeoutRunner = require("../utils/isomorphic/timeoutRunner");
-var _webSocket = require("./webSocket");
-/**
- * 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.
- */
-
-// This is here just for api generation and checking.
-
-class BrowserType extends _channelOwner.ChannelOwner {
-  constructor(...args) {
-    super(...args);
-    this._serverLauncher = void 0;
-    this._contexts = new Set();
-    this._playwright = void 0;
+module.exports = __toCommonJS(browserType_exports);
+var import_browser = require("./browser");
+var import_browserContext = require("./browserContext");
+var import_channelOwner = require("./channelOwner");
+var import_clientHelper = require("./clientHelper");
+var import_events = require("./events");
+var import_assert = require("../utils/isomorphic/assert");
+var import_headers = require("../utils/isomorphic/headers");
+var import_time = require("../utils/isomorphic/time");
+var import_timeoutRunner = require("../utils/isomorphic/timeoutRunner");
+var import_webSocket = require("./webSocket");
+class BrowserType extends import_channelOwner.ChannelOwner {
+  constructor() {
+    super(...arguments);
+    this._contexts = /* @__PURE__ */ new Set();
   }
   static from(browserType) {
     return browserType._object;
   }
   executablePath() {
-    if (!this._initializer.executablePath) throw new Error('Browser is not supported on current platform');
+    if (!this._initializer.executablePath)
+      throw new Error("Browser is not supported on current platform");
     return this._initializer.executablePath;
   }
   name() {
     return this._initializer.name;
   }
   async launch(options = {}) {
-    var _this$_playwright$_de;
-    (0, _assert.assert)(!options.userDataDir, 'userDataDir option is not supported in `browserType.launch`. Use `browserType.launchPersistentContext` instead');
-    (0, _assert.assert)(!options.port, 'Cannot specify a port without launching as a server.');
-    const logger = options.logger || ((_this$_playwright$_de = this._playwright._defaultLaunchOptions) === null || _this$_playwright$_de === void 0 ? void 0 : _this$_playwright$_de.logger);
-    options = {
-      ...this._playwright._defaultLaunchOptions,
-      ...options
-    };
+    (0, import_assert.assert)(!options.userDataDir, "userDataDir option is not supported in `browserType.launch`. Use `browserType.launchPersistentContext` instead");
+    (0, import_assert.assert)(!options.port, "Cannot specify a port without launching as a server.");
+    const logger = options.logger || this._playwright._defaultLaunchOptions?.logger;
+    options = { ...this._playwright._defaultLaunchOptions, ...options };
     const launchOptions = {
       ...options,
-      ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : undefined,
+      ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : void 0,
       ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
-      env: options.env ? (0, _clientHelper.envObjectToArray)(options.env) : undefined
+      env: options.env ? (0, import_clientHelper.envObjectToArray)(options.env) : void 0
     };
     return await this._wrapApiCall(async () => {
-      const browser = _browser3.Browser.from((await this._channel.launch(launchOptions)).browser);
+      const browser = import_browser.Browser.from((await this._channel.launch(launchOptions)).browser);
       this._didLaunchBrowser(browser, options, logger);
       return browser;
     });
   }
   async launchServer(options = {}) {
-    if (!this._serverLauncher) throw new Error('Launching server is not supported');
-    options = {
-      ...this._playwright._defaultLaunchOptions,
-      ...options
-    };
+    if (!this._serverLauncher)
+      throw new Error("Launching server is not supported");
+    options = { ...this._playwright._defaultLaunchOptions, ...options };
     return await this._serverLauncher.launchServer(options);
   }
   async launchPersistentContext(userDataDir, options = {}) {
-    var _this$_playwright$_de2;
-    const logger = options.logger || ((_this$_playwright$_de2 = this._playwright._defaultLaunchOptions) === null || _this$_playwright$_de2 === void 0 ? void 0 : _this$_playwright$_de2.logger);
-    (0, _assert.assert)(!options.port, 'Cannot specify a port without launching as a server.');
-    options = {
-      ...this._playwright._defaultLaunchOptions,
-      ...this._playwright._defaultContextOptions,
-      ...options
-    };
-    const contextParams = await (0, _browserContext.prepareBrowserContextParams)(this._platform, options);
+    const logger = options.logger || this._playwright._defaultLaunchOptions?.logger;
+    (0, import_assert.assert)(!options.port, "Cannot specify a port without launching as a server.");
+    options = { ...this._playwright._defaultLaunchOptions, ...this._playwright._defaultContextOptions, ...options };
+    const contextParams = await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options);
     const persistentParams = {
       ...contextParams,
-      ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : undefined,
+      ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : void 0,
       ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
-      env: options.env ? (0, _clientHelper.envObjectToArray)(options.env) : undefined,
+      env: options.env ? (0, import_clientHelper.envObjectToArray)(options.env) : void 0,
       channel: options.channel,
       userDataDir: this._platform.path().isAbsolute(userDataDir) || !userDataDir ? userDataDir : this._platform.path().resolve(userDataDir)
     };
     return await this._wrapApiCall(async () => {
       const result = await this._channel.launchPersistentContext(persistentParams);
-      const context = _browserContext.BrowserContext.from(result.context);
+      const context = import_browserContext.BrowserContext.from(result.context);
       await this._didCreateContext(context, contextParams, options, logger);
       return context;
     });
   }
   async connect(optionsOrWsEndpoint, options) {
-    if (typeof optionsOrWsEndpoint === 'string') return await this._connect({
-      ...options,
-      wsEndpoint: optionsOrWsEndpoint
-    });
-    (0, _assert.assert)(optionsOrWsEndpoint.wsEndpoint, 'options.wsEndpoint is required');
+    if (typeof optionsOrWsEndpoint === "string")
+      return await this._connect({ ...options, wsEndpoint: optionsOrWsEndpoint });
+    (0, import_assert.assert)(optionsOrWsEndpoint.wsEndpoint, "options.wsEndpoint is required");
     return await this._connect(optionsOrWsEndpoint);
   }
   async _connect(params) {
     const logger = params.logger;
     return await this._wrapApiCall(async () => {
-      var _params$exposeNetwork;
-      const deadline = params.timeout ? (0, _time.monotonicTime)() + params.timeout : 0;
-      const headers = {
-        'x-playwright-browser': this.name(),
-        ...params.headers
-      };
+      const deadline = params.timeout ? (0, import_time.monotonicTime)() + params.timeout : 0;
+      const headers = { "x-playwright-browser": this.name(), ...params.headers };
       const connectParams = {
         wsEndpoint: params.wsEndpoint,
         headers,
-        exposeNetwork: (_params$exposeNetwork = params.exposeNetwork) !== null && _params$exposeNetwork !== void 0 ? _params$exposeNetwork : params._exposeNetwork,
+        exposeNetwork: params.exposeNetwork ?? params._exposeNetwork,
         slowMo: params.slowMo,
         timeout: params.timeout
       };
-      if (params.__testHookRedirectPortForwarding) connectParams.socksProxyRedirectPortForTest = params.__testHookRedirectPortForwarding;
-      const connection = await (0, _webSocket.connectOverWebSocket)(this._connection, connectParams);
+      if (params.__testHookRedirectPortForwarding)
+        connectParams.socksProxyRedirectPortForTest = params.__testHookRedirectPortForwarding;
+      const connection = await (0, import_webSocket.connectOverWebSocket)(this._connection, connectParams);
       let browser;
-      connection.on('close', () => {
-        // Emulate all pages, contexts and the browser closing upon disconnect.
-        for (const context of ((_browser = browser) === null || _browser === void 0 ? void 0 : _browser.contexts()) || []) {
-          var _browser;
-          for (const page of context.pages()) page._onClose();
+      connection.on("close", () => {
+        for (const context of browser?.contexts() || []) {
+          for (const page of context.pages())
+            page._onClose();
           context._onClose();
         }
-        setTimeout(() => {
-          var _browser2;
-          return (_browser2 = browser) === null || _browser2 === void 0 ? void 0 : _browser2._didClose();
-        }, 0);
+        setTimeout(() => browser?._didClose(), 0);
       });
-      const result = await (0, _timeoutRunner.raceAgainstDeadline)(async () => {
-        // For tests.
-        if (params.__testHookBeforeCreateBrowser) await params.__testHookBeforeCreateBrowser();
+      const result = await (0, import_timeoutRunner.raceAgainstDeadline)(async () => {
+        if (params.__testHookBeforeCreateBrowser)
+          await params.__testHookBeforeCreateBrowser();
         const playwright = await connection.initializePlaywright();
         if (!playwright._initializer.preLaunchedBrowser) {
           connection.close();
-          throw new Error('Malformed endpoint. Did you use BrowserType.launchServer method?');
+          throw new Error("Malformed endpoint. Did you use BrowserType.launchServer method?");
         }
         playwright._setSelectors(this._playwright.selectors);
-        browser = _browser3.Browser.from(playwright._initializer.preLaunchedBrowser);
+        browser = import_browser.Browser.from(playwright._initializer.preLaunchedBrowser);
         this._didLaunchBrowser(browser, {}, logger);
         browser._shouldCloseConnectionOnClose = true;
-        browser.on(_events.Events.Browser.Disconnected, () => connection.close());
+        browser.on(import_events.Events.Browser.Disconnected, () => connection.close());
         return browser;
       }, deadline);
       if (!result.timedOut) {
@@ -166,23 +144,26 @@ class BrowserType extends _channelOwner.ChannelOwner {
     });
   }
   async connectOverCDP(endpointURLOrOptions, options) {
-    if (typeof endpointURLOrOptions === 'string') return await this._connectOverCDP(endpointURLOrOptions, options);
-    const endpointURL = 'endpointURL' in endpointURLOrOptions ? endpointURLOrOptions.endpointURL : endpointURLOrOptions.wsEndpoint;
-    (0, _assert.assert)(endpointURL, 'Cannot connect over CDP without wsEndpoint.');
+    if (typeof endpointURLOrOptions === "string")
+      return await this._connectOverCDP(endpointURLOrOptions, options);
+    const endpointURL = "endpointURL" in endpointURLOrOptions ? endpointURLOrOptions.endpointURL : endpointURLOrOptions.wsEndpoint;
+    (0, import_assert.assert)(endpointURL, "Cannot connect over CDP without wsEndpoint.");
     return await this.connectOverCDP(endpointURL, endpointURLOrOptions);
   }
   async _connectOverCDP(endpointURL, params = {}) {
-    if (this.name() !== 'chromium') throw new Error('Connecting over CDP is only supported in Chromium.');
-    const headers = params.headers ? (0, _headers.headersObjectToArray)(params.headers) : undefined;
+    if (this.name() !== "chromium")
+      throw new Error("Connecting over CDP is only supported in Chromium.");
+    const headers = params.headers ? (0, import_headers.headersObjectToArray)(params.headers) : void 0;
     const result = await this._channel.connectOverCDP({
       endpointURL,
       headers,
       slowMo: params.slowMo,
       timeout: params.timeout
     });
-    const browser = _browser3.Browser.from(result.browser);
+    const browser = import_browser.Browser.from(result.browser);
     this._didLaunchBrowser(browser, {}, params.logger);
-    if (result.defaultContext) await this._didCreateContext(_browserContext.BrowserContext.from(result.defaultContext), {}, {}, params.logger);
+    if (result.defaultContext)
+      await this._didCreateContext(import_browserContext.BrowserContext.from(result.defaultContext), {}, {}, params.logger);
     return browser;
   }
   _didLaunchBrowser(browser, browserOptions, logger) {
@@ -195,8 +176,10 @@ class BrowserType extends _channelOwner.ChannelOwner {
     context._browserType = this;
     this._contexts.add(context);
     context._setOptions(contextOptions, browserOptions);
-    if (this._playwright._defaultContextTimeout !== undefined) context.setDefaultTimeout(this._playwright._defaultContextTimeout);
-    if (this._playwright._defaultContextNavigationTimeout !== undefined) context.setDefaultNavigationTimeout(this._playwright._defaultContextNavigationTimeout);
+    if (this._playwright._defaultContextTimeout !== void 0)
+      context.setDefaultTimeout(this._playwright._defaultContextTimeout);
+    if (this._playwright._defaultContextNavigationTimeout !== void 0)
+      context.setDefaultNavigationTimeout(this._playwright._defaultContextNavigationTimeout);
     await this._instrumentation.runAfterCreateBrowserContext(context);
   }
   async _willCloseContext(context) {
@@ -204,4 +187,7 @@ class BrowserType extends _channelOwner.ChannelOwner {
     await this._instrumentation.runBeforeCloseBrowserContext(context);
   }
 }
-exports.BrowserType = BrowserType;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserType
+});

package/lib/client/cdpSession.js

@@ -1,36 +1,34 @@
 "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 cdpSession_exports = {};
+__export(cdpSession_exports, {
+  CDPSession: () => CDPSession
 });
-exports.CDPSession = void 0;
-var _channelOwner = require("./channelOwner");
-/**
- * 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 CDPSession extends _channelOwner.ChannelOwner {
+module.exports = __toCommonJS(cdpSession_exports);
+var import_channelOwner = require("./channelOwner");
+class CDPSession extends import_channelOwner.ChannelOwner {
   static from(cdpSession) {
     return cdpSession._object;
   }
   constructor(parent, type, guid, initializer) {
     super(parent, type, guid, initializer);
-    this._channel.on('event', ({
-      method,
-      params
-    }) => {
+    this._channel.on("event", ({ method, params }) => {
       this.emit(method, params);
     });
     this.on = super.on;
@@ -40,14 +38,14 @@ class CDPSession extends _channelOwner.ChannelOwner {
     this.once = super.once;
   }
   async send(method, params) {
-    const result = await this._channel.send({
-      method,
-      params
-    });
+    const result = await this._channel.send({ method, params });
     return result.result;
   }
   async detach() {
     return await this._channel.detach();
   }
 }
-exports.CDPSession = CDPSession;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CDPSession
+});