First Commit

node_modules/playwright-core/lib/client/browser.js

@@ -0,0 +1,173 @@
+"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 browser_exports = {};
+__export(browser_exports, {
+  Browser: () => Browser
+});
+module.exports = __toCommonJS(browser_exports);
+var import_artifact = require("./artifact");
+var import_browserContext = require("./browserContext");
+var import_cdpSession = require("./cdpSession");
+var import_channelOwner = require("./channelOwner");
+var import_errors = require("./errors");
+var import_events = require("./events");
+var import_fileUtils = require("./fileUtils");
+class Browser extends import_channelOwner.ChannelOwner {
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._contexts = /* @__PURE__ */ new Set();
+    this._isConnected = true;
+    this._shouldCloseConnectionOnClose = false;
+    this._options = {};
+    this._name = initializer.name;
+    this._channel.on("context", ({ context }) => this._didCreateContext(import_browserContext.BrowserContext.from(context)));
+    this._channel.on("close", () => this._didClose());
+    this._closedPromise = new Promise((f) => this.once(import_events.Events.Browser.Disconnected, f));
+  }
+  static from(browser) {
+    return browser._object;
+  }
+  browserType() {
+    return this._browserType;
+  }
+  async newContext(options = {}) {
+    return await this._innerNewContext(options, false);
+  }
+  async _newContextForReuse(options = {}) {
+    return await this._innerNewContext(options, true);
+  }
+  async _disconnectFromReusedContext(reason) {
+    const context = [...this._contexts].find((context2) => context2._forReuse);
+    if (!context)
+      return;
+    await this._instrumentation.runBeforeCloseBrowserContext(context);
+    for (const page of context.pages())
+      page._onClose();
+    context._onClose();
+    await this._channel.disconnectFromReusedContext({ reason });
+  }
+  async _innerNewContext(options = {}, forReuse) {
+    options = this._browserType._playwright.selectors._withSelectorOptions({
+      ...this._browserType._playwright._defaultContextOptions,
+      ...options
+    });
+    const contextOptions = await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options);
+    const response = forReuse ? await this._channel.newContextForReuse(contextOptions) : await this._channel.newContext(contextOptions);
+    const context = import_browserContext.BrowserContext.from(response.context);
+    if (forReuse)
+      context._forReuse = true;
+    if (options.logger)
+      context._logger = options.logger;
+    await context._initializeHarFromOptions(options.recordHar);
+    await this._instrumentation.runAfterCreateBrowserContext(context);
+    return context;
+  }
+  _connectToBrowserType(browserType, browserOptions, logger) {
+    this._browserType = browserType;
+    this._options = browserOptions;
+    this._logger = logger;
+    for (const context of this._contexts)
+      this._setupBrowserContext(context);
+  }
+  _didCreateContext(context) {
+    context._browser = this;
+    this._contexts.add(context);
+    if (this._browserType)
+      this._setupBrowserContext(context);
+  }
+  _setupBrowserContext(context) {
+    context._logger = this._logger;
+    context.tracing._tracesDir = this._options.tracesDir;
+    this._browserType._contexts.add(context);
+    this._browserType._playwright.selectors._contextsForSelectors.add(context);
+    context.setDefaultTimeout(this._browserType._playwright._defaultContextTimeout);
+    context.setDefaultNavigationTimeout(this._browserType._playwright._defaultContextNavigationTimeout);
+  }
+  contexts() {
+    return [...this._contexts];
+  }
+  version() {
+    return this._initializer.version;
+  }
+  async newPage(options = {}) {
+    return await this._wrapApiCall(async () => {
+      const context = await this.newContext(options);
+      const page = await context.newPage();
+      page._ownedContext = context;
+      context._ownerPage = page;
+      return page;
+    }, { title: "Create page" });
+  }
+  isConnected() {
+    return this._isConnected;
+  }
+  async newBrowserCDPSession() {
+    return import_cdpSession.CDPSession.from((await this._channel.newBrowserCDPSession()).session);
+  }
+  async _launchServer(options = {}) {
+    const serverLauncher = this._browserType._serverLauncher;
+    const browserImpl = this._connection.toImpl?.(this);
+    if (!serverLauncher || !browserImpl)
+      throw new Error("Launching server is not supported");
+    return await serverLauncher.launchServerOnExistingBrowser(browserImpl, {
+      _sharedBrowser: true,
+      ...options
+    });
+  }
+  async startTracing(page, options = {}) {
+    this._path = options.path;
+    await this._channel.startTracing({ ...options, page: page ? page._channel : void 0 });
+  }
+  async stopTracing() {
+    const artifact = import_artifact.Artifact.from((await this._channel.stopTracing()).artifact);
+    const buffer = await artifact.readIntoBuffer();
+    await artifact.delete();
+    if (this._path) {
+      await (0, import_fileUtils.mkdirIfNeeded)(this._platform, this._path);
+      await this._platform.fs().promises.writeFile(this._path, buffer);
+      this._path = void 0;
+    }
+    return buffer;
+  }
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+  async close(options = {}) {
+    this._closeReason = options.reason;
+    try {
+      if (this._shouldCloseConnectionOnClose)
+        this._connection.close();
+      else
+        await this._channel.close(options);
+      await this._closedPromise;
+    } catch (e) {
+      if ((0, import_errors.isTargetClosedError)(e))
+        return;
+      throw e;
+    }
+  }
+  _didClose() {
+    this._isConnected = false;
+    this.emit(import_events.Events.Browser.Disconnected, this);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Browser
+});