stably 4.12.1 → 4.12.2

package/dist/node_modules/playwright-core/lib/client/pageAgent.js

@@ -0,0 +1,64 @@
+"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 pageAgent_exports = {};
+__export(pageAgent_exports, {
+  PageAgent: () => PageAgent
+});
+module.exports = __toCommonJS(pageAgent_exports);
+var import_channelOwner = require("./channelOwner");
+var import_events = require("./events");
+var import_page = require("./page");
+class PageAgent extends import_channelOwner.ChannelOwner {
+  static from(channel) {
+    return channel._object;
+  }
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._page = import_page.Page.from(initializer.page);
+    this._channel.on("turn", (params) => this.emit(import_events.Events.PageAgent.Turn, params));
+  }
+  async expect(expectation, options = {}) {
+    const timeout = options.timeout ?? this._expectTimeout ?? 5e3;
+    await this._channel.expect({ expectation, ...options, timeout });
+  }
+  async perform(task, options = {}) {
+    const timeout = this._page._timeoutSettings.timeout(options);
+    const { usage } = await this._channel.perform({ task, ...options, timeout });
+    return { usage };
+  }
+  async extract(query, schema, options = {}) {
+    const timeout = this._page._timeoutSettings.timeout(options);
+    const { result, usage } = await this._channel.extract({ query, schema: this._page._platform.zodToJsonSchema(schema), ...options, timeout });
+    return { result, usage };
+  }
+  async usage() {
+    const { usage } = await this._channel.usage({});
+    return usage;
+  }
+  async dispose() {
+    await this._channel.dispose();
+  }
+  async [Symbol.asyncDispose]() {
+    await this.dispose();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PageAgent
+});

package/dist/node_modules/playwright-core/lib/client/platform.js

@@ -0,0 +1,77 @@
+"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 platform_exports = {};
+__export(platform_exports, {
+  emptyPlatform: () => emptyPlatform
+});
+module.exports = __toCommonJS(platform_exports);
+var import_colors = require("../utils/isomorphic/colors");
+const noopZone = {
+  push: () => noopZone,
+  pop: () => noopZone,
+  run: (func) => func(),
+  data: () => void 0
+};
+const emptyPlatform = {
+  name: "empty",
+  boxedStackPrefixes: () => [],
+  calculateSha1: async () => {
+    throw new Error("Not implemented");
+  },
+  colors: import_colors.webColors,
+  createGuid: () => {
+    throw new Error("Not implemented");
+  },
+  defaultMaxListeners: () => 10,
+  env: {},
+  fs: () => {
+    throw new Error("Not implemented");
+  },
+  inspectCustom: void 0,
+  isDebugMode: () => false,
+  isJSDebuggerAttached: () => false,
+  isLogEnabled(name) {
+    return false;
+  },
+  isUnderTest: () => false,
+  log(name, message) {
+  },
+  path: () => {
+    throw new Error("Function not implemented.");
+  },
+  pathSeparator: "/",
+  showInternalStackFrames: () => false,
+  streamFile(path, writable) {
+    throw new Error("Streams are not available");
+  },
+  streamReadable: (channel) => {
+    throw new Error("Streams are not available");
+  },
+  streamWritable: (channel) => {
+    throw new Error("Streams are not available");
+  },
+  zodToJsonSchema: (schema) => {
+    throw new Error("Zod is not available");
+  },
+  zones: { empty: noopZone, current: () => noopZone }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  emptyPlatform
+});

package/dist/node_modules/playwright-core/lib/client/playwright.js

@@ -0,0 +1,71 @@
+"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 playwright_exports = {};
+__export(playwright_exports, {
+  Playwright: () => Playwright
+});
+module.exports = __toCommonJS(playwright_exports);
+var import_android = require("./android");
+var import_browser = require("./browser");
+var import_browserType = require("./browserType");
+var import_channelOwner = require("./channelOwner");
+var import_electron = require("./electron");
+var import_errors = require("./errors");
+var import_fetch = require("./fetch");
+var import_selectors = require("./selectors");
+class Playwright extends import_channelOwner.ChannelOwner {
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this.request = new import_fetch.APIRequest(this);
+    this.chromium = import_browserType.BrowserType.from(initializer.chromium);
+    this.chromium._playwright = this;
+    this.firefox = import_browserType.BrowserType.from(initializer.firefox);
+    this.firefox._playwright = this;
+    this.webkit = import_browserType.BrowserType.from(initializer.webkit);
+    this.webkit._playwright = this;
+    this._android = import_android.Android.from(initializer.android);
+    this._android._playwright = this;
+    this._electron = import_electron.Electron.from(initializer.electron);
+    this._electron._playwright = this;
+    this.devices = this._connection.localUtils()?.devices ?? {};
+    this.selectors = new import_selectors.Selectors(this._connection._platform);
+    this.errors = { TimeoutError: import_errors.TimeoutError };
+  }
+  static from(channel) {
+    return channel._object;
+  }
+  _browserTypes() {
+    return [this.chromium, this.firefox, this.webkit];
+  }
+  _preLaunchedBrowser() {
+    const browser = import_browser.Browser.from(this._initializer.preLaunchedBrowser);
+    browser._connectToBrowserType(this[browser._name], {}, void 0);
+    return browser;
+  }
+  _allContexts() {
+    return this._browserTypes().flatMap((type) => [...type._contexts]);
+  }
+  _allPages() {
+    return this._allContexts().flatMap((context) => context.pages());
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Playwright
+});

package/dist/node_modules/playwright-core/lib/client/selectors.js

@@ -0,0 +1,55 @@
+"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 selectors_exports = {};
+__export(selectors_exports, {
+  Selectors: () => Selectors
+});
+module.exports = __toCommonJS(selectors_exports);
+var import_clientHelper = require("./clientHelper");
+var import_locator = require("./locator");
+class Selectors {
+  constructor(platform) {
+    this._selectorEngines = [];
+    this._contextsForSelectors = /* @__PURE__ */ new Set();
+    this._platform = platform;
+  }
+  async register(name, script, options = {}) {
+    if (this._selectorEngines.some((engine) => engine.name === name))
+      throw new Error(`selectors.register: "${name}" selector engine has been already registered`);
+    const source = await (0, import_clientHelper.evaluationScript)(this._platform, script, void 0, false);
+    const selectorEngine = { ...options, name, source };
+    for (const context of this._contextsForSelectors)
+      await context._channel.registerSelectorEngine({ selectorEngine });
+    this._selectorEngines.push(selectorEngine);
+  }
+  setTestIdAttribute(attributeName) {
+    this._testIdAttributeName = attributeName;
+    (0, import_locator.setTestIdAttribute)(attributeName);
+    for (const context of this._contextsForSelectors)
+      context._channel.setTestIdAttributeName({ testIdAttributeName: attributeName }).catch(() => {
+      });
+  }
+  _withSelectorOptions(options) {
+    return { ...options, selectorEngines: this._selectorEngines, testIdAttributeName: this._testIdAttributeName };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Selectors
+});

package/dist/node_modules/playwright-core/lib/client/stream.js

@@ -0,0 +1,39 @@
+"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 stream_exports = {};
+__export(stream_exports, {
+  Stream: () => Stream
+});
+module.exports = __toCommonJS(stream_exports);
+var import_channelOwner = require("./channelOwner");
+class Stream extends import_channelOwner.ChannelOwner {
+  static from(Stream2) {
+    return Stream2._object;
+  }
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+  }
+  stream() {
+    return this._platform.streamReadable(this._channel);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Stream
+});

package/dist/node_modules/playwright-core/lib/client/timeoutSettings.js

@@ -0,0 +1,79 @@
+"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 timeoutSettings_exports = {};
+__export(timeoutSettings_exports, {
+  TimeoutSettings: () => TimeoutSettings
+});
+module.exports = __toCommonJS(timeoutSettings_exports);
+var import_time = require("../utils/isomorphic/time");
+class TimeoutSettings {
+  constructor(platform, parent) {
+    this._parent = parent;
+    this._platform = platform;
+  }
+  setDefaultTimeout(timeout) {
+    this._defaultTimeout = timeout;
+  }
+  setDefaultNavigationTimeout(timeout) {
+    this._defaultNavigationTimeout = timeout;
+  }
+  defaultNavigationTimeout() {
+    return this._defaultNavigationTimeout;
+  }
+  defaultTimeout() {
+    return this._defaultTimeout;
+  }
+  navigationTimeout(options) {
+    if (typeof options.timeout === "number")
+      return options.timeout;
+    if (this._defaultNavigationTimeout !== void 0)
+      return this._defaultNavigationTimeout;
+    if (this._platform.isDebugMode())
+      return 0;
+    if (this._defaultTimeout !== void 0)
+      return this._defaultTimeout;
+    if (this._parent)
+      return this._parent.navigationTimeout(options);
+    return import_time.DEFAULT_PLAYWRIGHT_TIMEOUT;
+  }
+  timeout(options) {
+    if (typeof options.timeout === "number")
+      return options.timeout;
+    if (this._platform.isDebugMode())
+      return 0;
+    if (this._defaultTimeout !== void 0)
+      return this._defaultTimeout;
+    if (this._parent)
+      return this._parent.timeout(options);
+    return import_time.DEFAULT_PLAYWRIGHT_TIMEOUT;
+  }
+  launchTimeout(options) {
+    if (typeof options.timeout === "number")
+      return options.timeout;
+    if (this._platform.isDebugMode())
+      return 0;
+    if (this._parent)
+      return this._parent.launchTimeout(options);
+    return import_time.DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TimeoutSettings
+});

package/dist/node_modules/playwright-core/lib/client/tracing.js

@@ -0,0 +1,119 @@
+"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 tracing_exports = {};
+__export(tracing_exports, {
+  Tracing: () => Tracing
+});
+module.exports = __toCommonJS(tracing_exports);
+var import_artifact = require("./artifact");
+var import_channelOwner = require("./channelOwner");
+class Tracing extends import_channelOwner.ChannelOwner {
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._includeSources = false;
+    this._isLive = false;
+    this._isTracing = false;
+  }
+  static from(channel) {
+    return channel._object;
+  }
+  async start(options = {}) {
+    await this._wrapApiCall(async () => {
+      this._includeSources = !!options.sources;
+      this._isLive = !!options._live;
+      await this._channel.tracingStart({
+        name: options.name,
+        snapshots: options.snapshots,
+        screenshots: options.screenshots,
+        live: options._live
+      });
+      const { traceName } = await this._channel.tracingStartChunk({ name: options.name, title: options.title });
+      await this._startCollectingStacks(traceName, this._isLive);
+    });
+  }
+  async startChunk(options = {}) {
+    await this._wrapApiCall(async () => {
+      const { traceName } = await this._channel.tracingStartChunk(options);
+      await this._startCollectingStacks(traceName, this._isLive);
+    });
+  }
+  async group(name, options = {}) {
+    await this._channel.tracingGroup({ name, location: options.location });
+  }
+  async groupEnd() {
+    await this._channel.tracingGroupEnd();
+  }
+  async _startCollectingStacks(traceName, live) {
+    if (!this._isTracing) {
+      this._isTracing = true;
+      this._connection.setIsTracing(true);
+    }
+    const result = await this._connection.localUtils()?.tracingStarted({ tracesDir: this._tracesDir, traceName, live });
+    this._stacksId = result?.stacksId;
+  }
+  async stopChunk(options = {}) {
+    await this._wrapApiCall(async () => {
+      await this._doStopChunk(options.path);
+    });
+  }
+  async stop(options = {}) {
+    await this._wrapApiCall(async () => {
+      await this._doStopChunk(options.path);
+      await this._channel.tracingStop();
+    });
+  }
+  async _doStopChunk(filePath) {
+    this._resetStackCounter();
+    if (!filePath) {
+      await this._channel.tracingStopChunk({ mode: "discard" });
+      if (this._stacksId)
+        await this._connection.localUtils().traceDiscarded({ stacksId: this._stacksId });
+      return;
+    }
+    const localUtils = this._connection.localUtils();
+    if (!localUtils)
+      throw new Error("Cannot save trace in thin clients");
+    const isLocal = !this._connection.isRemote();
+    if (isLocal) {
+      const result2 = await this._channel.tracingStopChunk({ mode: "entries" });
+      await localUtils.zip({ zipFile: filePath, entries: result2.entries, mode: "write", stacksId: this._stacksId, includeSources: this._includeSources });
+      return;
+    }
+    const result = await this._channel.tracingStopChunk({ mode: "archive" });
+    if (!result.artifact) {
+      if (this._stacksId)
+        await localUtils.traceDiscarded({ stacksId: this._stacksId });
+      return;
+    }
+    const artifact = import_artifact.Artifact.from(result.artifact);
+    await artifact.saveAs(filePath);
+    await artifact.delete();
+    await localUtils.zip({ zipFile: filePath, entries: [], mode: "append", stacksId: this._stacksId, includeSources: this._includeSources });
+  }
+  _resetStackCounter() {
+    if (this._isTracing) {
+      this._isTracing = false;
+      this._connection.setIsTracing(false);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Tracing
+});

package/dist/node_modules/playwright-core/lib/client/types.js

@@ -0,0 +1,28 @@
+"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 types_exports = {};
+__export(types_exports, {
+  kLifecycleEvents: () => kLifecycleEvents
+});
+module.exports = __toCommonJS(types_exports);
+const kLifecycleEvents = /* @__PURE__ */ new Set(["load", "domcontentloaded", "networkidle", "commit"]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  kLifecycleEvents
+});

package/dist/node_modules/playwright-core/lib/client/video.js

@@ -0,0 +1,63 @@
+"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 video_exports = {};
+__export(video_exports, {
+  Video: () => Video
+});
+module.exports = __toCommonJS(video_exports);
+var import_artifact = require("./artifact");
+class Video {
+  constructor(page, connection, artifact) {
+    this._isRemote = false;
+    this._page = page;
+    this._isRemote = connection.isRemote();
+    this._artifact = artifact;
+  }
+  async start(options = {}) {
+    const result = await this._page._channel.videoStart(options);
+    this._artifact = import_artifact.Artifact.from(result.artifact);
+  }
+  async stop(options = {}) {
+    await this._page._wrapApiCall(async () => {
+      await this._page._channel.videoStop();
+      if (options.path)
+        await this.saveAs(options.path);
+    });
+  }
+  async path() {
+    if (this._isRemote)
+      throw new Error(`Path is not available when connecting remotely. Use saveAs() to save a local copy.`);
+    if (!this._artifact)
+      throw new Error("Video recording has not been started.");
+    return this._artifact._initializer.absolutePath;
+  }
+  async saveAs(path) {
+    if (!this._artifact)
+      throw new Error("Video recording has not been started.");
+    return await this._artifact.saveAs(path);
+  }
+  async delete() {
+    if (this._artifact)
+      await this._artifact.delete();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Video
+});