@zohodesk/testinglibrary 3.2.13 → 3.2.14

package/playwright-mcp-test/node_modules/playwright-core/lib/client/artifact.js

@@ -1,79 +0,0 @@
-"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 artifact_exports = {};
-__export(artifact_exports, {
-  Artifact: () => Artifact
-});
-module.exports = __toCommonJS(artifact_exports);
-var import_channelOwner = require("./channelOwner");
-var import_stream = require("./stream");
-var import_fileUtils = require("./fileUtils");
-class Artifact extends import_channelOwner.ChannelOwner {
-  static from(channel) {
-    return channel._object;
-  }
-  async pathAfterFinished() {
-    if (this._connection.isRemote())
-      throw new Error(`Path is not available when connecting remotely. Use saveAs() to save a local copy.`);
-    return (await this._channel.pathAfterFinished()).value;
-  }
-  async saveAs(path) {
-    if (!this._connection.isRemote()) {
-      await this._channel.saveAs({ path });
-      return;
-    }
-    const result = await this._channel.saveAsStream();
-    const stream = import_stream.Stream.from(result.stream);
-    await (0, import_fileUtils.mkdirIfNeeded)(this._platform, path);
-    await new Promise((resolve, reject) => {
-      stream.stream().pipe(this._platform.fs().createWriteStream(path)).on("finish", resolve).on("error", reject);
-    });
-  }
-  async failure() {
-    return (await this._channel.failure()).error || null;
-  }
-  async createReadStream() {
-    const result = await this._channel.stream();
-    const stream = import_stream.Stream.from(result.stream);
-    return stream.stream();
-  }
-  async readIntoBuffer() {
-    const stream = await this.createReadStream();
-    return await new Promise((resolve, reject) => {
-      const chunks = [];
-      stream.on("data", (chunk) => {
-        chunks.push(chunk);
-      });
-      stream.on("end", () => {
-        resolve(Buffer.concat(chunks));
-      });
-      stream.on("error", reject);
-    });
-  }
-  async cancel() {
-    return await this._channel.cancel();
-  }
-  async delete() {
-    return await this._channel.delete();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Artifact
-});

package/playwright-mcp-test/node_modules/playwright-core/lib/client/browser.js

@@ -1,163 +0,0 @@
-"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 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
-});