@pedropaulovc/playwright-core 1.59.0-next

package/lib/server/bidi/bidiExecutionContext.js

@@ -0,0 +1,267 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bidiExecutionContext_exports = {};
+__export(bidiExecutionContext_exports, {
+  BidiExecutionContext: () => BidiExecutionContext,
+  createHandle: () => createHandle
+});
+module.exports = __toCommonJS(bidiExecutionContext_exports);
+var import_utils = require("../../utils");
+var import_utilityScriptSerializers = require("../../utils/isomorphic/utilityScriptSerializers");
+var js = __toESM(require("../javascript"));
+var dom = __toESM(require("../dom"));
+var bidi = __toESM(require("./third_party/bidiProtocol"));
+var import_bidiSerializer = require("./third_party/bidiSerializer");
+var import_bidiDeserializer = require("./bidiDeserializer");
+class BidiExecutionContext {
+  constructor(session, realmInfo) {
+    this._session = session;
+    if (realmInfo.type === "window") {
+      this._target = {
+        context: realmInfo.context,
+        sandbox: realmInfo.sandbox
+      };
+    } else {
+      this._target = {
+        realm: realmInfo.realm
+      };
+    }
+  }
+  async rawEvaluateJSON(expression) {
+    const response = await this._session.send("script.evaluate", {
+      expression,
+      target: this._target,
+      serializationOptions: {
+        maxObjectDepth: 10,
+        maxDomDepth: 10
+      },
+      awaitPromise: true,
+      userActivation: true
+    });
+    if (response.type === "success")
+      return (0, import_bidiDeserializer.deserializeBidiValue)(response.result);
+    if (response.type === "exception")
+      throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text);
+    throw new js.JavaScriptErrorInEvaluate("Unexpected response type: " + JSON.stringify(response));
+  }
+  async rawEvaluateHandle(context, expression) {
+    const response = await this._session.send("script.evaluate", {
+      expression,
+      target: this._target,
+      resultOwnership: bidi.Script.ResultOwnership.Root,
+      // Necessary for the handle to be returned.
+      serializationOptions: { maxObjectDepth: 0, maxDomDepth: 0 },
+      awaitPromise: true,
+      userActivation: true
+    });
+    if (response.type === "success") {
+      if ("handle" in response.result)
+        return createHandle(context, response.result);
+      throw new js.JavaScriptErrorInEvaluate("Cannot get handle: " + JSON.stringify(response.result));
+    }
+    if (response.type === "exception")
+      throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text);
+    throw new js.JavaScriptErrorInEvaluate("Unexpected response type: " + JSON.stringify(response));
+  }
+  async evaluateWithArguments(functionDeclaration, returnByValue, utilityScript, values, handles) {
+    const response = await this._session.send("script.callFunction", {
+      functionDeclaration,
+      target: this._target,
+      arguments: [
+        { handle: utilityScript._objectId },
+        ...values.map(import_bidiSerializer.BidiSerializer.serialize),
+        ...handles.map((handle) => ({ handle: handle._objectId }))
+      ],
+      resultOwnership: returnByValue ? void 0 : bidi.Script.ResultOwnership.Root,
+      // Necessary for the handle to be returned.
+      serializationOptions: returnByValue ? {} : { maxObjectDepth: 0, maxDomDepth: 0 },
+      awaitPromise: true,
+      userActivation: true
+    });
+    if (response.type === "exception")
+      throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text);
+    if (response.type === "success") {
+      if (returnByValue)
+        return (0, import_utilityScriptSerializers.parseEvaluationResultValue)((0, import_bidiDeserializer.deserializeBidiValue)(response.result));
+      return createHandle(utilityScript._context, response.result);
+    }
+    throw new js.JavaScriptErrorInEvaluate("Unexpected response type: " + JSON.stringify(response));
+  }
+  async getProperties(handle) {
+    const names = await handle.evaluate((object) => {
+      const names2 = [];
+      const descriptors = Object.getOwnPropertyDescriptors(object);
+      for (const name in descriptors) {
+        if (descriptors[name]?.enumerable)
+          names2.push(name);
+      }
+      return names2;
+    });
+    const values = await Promise.all(names.map(async (name) => {
+      const value = await this._rawCallFunction("(object, name) => object[name]", [{ handle: handle._objectId }, { type: "string", value: name }], true, false);
+      return createHandle(handle._context, value);
+    }));
+    const map = /* @__PURE__ */ new Map();
+    for (let i = 0; i < names.length; i++)
+      map.set(names[i], values[i]);
+    return map;
+  }
+  async releaseHandle(handle) {
+    if (!handle._objectId)
+      return;
+    await this._session.send("script.disown", {
+      target: this._target,
+      handles: [handle._objectId]
+    });
+  }
+  async nodeIdForElementHandle(handle) {
+    const shared = await this._remoteValueForReference({ handle: handle._objectId });
+    if (!("sharedId" in shared))
+      throw new Error("Element is not a node");
+    return {
+      sharedId: shared.sharedId
+    };
+  }
+  async remoteObjectForNodeId(context, nodeId) {
+    const result = await this._remoteValueForReference(nodeId, true);
+    if (!("handle" in result))
+      throw new Error("Can't get remote object for nodeId");
+    return createHandle(context, result);
+  }
+  async contentFrameIdForFrame(handle) {
+    const contentWindow = await this._rawCallFunction("e => e.contentWindow", [{ handle: handle._objectId }]);
+    if (contentWindow?.type === "window")
+      return contentWindow.value.context;
+    return null;
+  }
+  async frameIdForWindowHandle(handle) {
+    if (!handle._objectId)
+      throw new Error("JSHandle is not a DOM node handle");
+    const contentWindow = await this._remoteValueForReference({ handle: handle._objectId });
+    if (contentWindow.type === "window")
+      return contentWindow.value.context;
+    return null;
+  }
+  async _remoteValueForReference(reference, createHandle2) {
+    return await this._rawCallFunction("e => e", [reference], createHandle2);
+  }
+  async _rawCallFunction(functionDeclaration, args, createHandle2, awaitPromise = true) {
+    const response = await this._session.send("script.callFunction", {
+      functionDeclaration,
+      target: this._target,
+      arguments: args,
+      // "Root" is necessary for the handle to be returned.
+      resultOwnership: createHandle2 ? bidi.Script.ResultOwnership.Root : bidi.Script.ResultOwnership.None,
+      serializationOptions: { maxObjectDepth: 0, maxDomDepth: 0 },
+      awaitPromise,
+      userActivation: true
+    });
+    if (response.type === "exception")
+      throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text);
+    if (response.type === "success")
+      return response.result;
+    throw new js.JavaScriptErrorInEvaluate("Unexpected response type: " + JSON.stringify(response));
+  }
+}
+function renderPreview(remoteObject, nested = false) {
+  switch (remoteObject.type) {
+    case "undefined":
+    case "null":
+      return remoteObject.type;
+    case "number":
+    case "boolean":
+    case "string":
+      return String(remoteObject.value);
+    case "bigint":
+      return `${remoteObject.value}n`;
+    case "date":
+      return String(new Date(remoteObject.value));
+    case "regexp":
+      return String(new RegExp(remoteObject.value.pattern, remoteObject.value.flags));
+    case "node":
+      return remoteObject.value?.localName || "Node";
+    case "object":
+      if (nested)
+        return "Object";
+      const tokens = [];
+      for (const [name, value] of remoteObject.value || []) {
+        if (typeof name === "string")
+          tokens.push(`${name}: ${renderPreview(value, true)}`);
+      }
+      return `{${tokens.join(", ")}}`;
+    case "array":
+    case "htmlcollection":
+    case "nodelist":
+      if (nested || !remoteObject.value)
+        return remoteObject.value ? `Array(${remoteObject.value.length})` : "Array";
+      return `[${remoteObject.value.map((v) => renderPreview(v, true)).join(", ")}]`;
+    case "map":
+      return remoteObject.value ? `Map(${remoteObject.value.length})` : "Map";
+    case "set":
+      return remoteObject.value ? `Set(${remoteObject.value.length})` : "Set";
+    case "arraybuffer":
+      return "ArrayBuffer";
+    case "error":
+      return "Error";
+    case "function":
+      return "Function";
+    case "generator":
+      return "Generator";
+    case "promise":
+      return "Promise";
+    case "proxy":
+      return "Proxy";
+    case "symbol":
+      return "Symbol()";
+    case "typedarray":
+      return "TypedArray";
+    case "weakmap":
+      return "WeakMap";
+    case "weakset":
+      return "WeakSet";
+    case "window":
+      return "Window";
+  }
+}
+function createHandle(context, remoteObject) {
+  if (remoteObject.type === "node") {
+    (0, import_utils.assert)(context instanceof dom.FrameExecutionContext);
+    return new dom.ElementHandle(context, remoteObject.handle);
+  }
+  const objectId = "handle" in remoteObject ? remoteObject.handle : void 0;
+  const preview = renderPreview(remoteObject);
+  const handle = new js.JSHandle(context, remoteObject.type, preview, objectId, (0, import_bidiDeserializer.deserializeBidiValue)(remoteObject));
+  handle._setPreview(preview);
+  return handle;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BidiExecutionContext,
+  createHandle
+});

package/lib/server/bidi/bidiFirefox.js

@@ -0,0 +1,128 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bidiFirefox_exports = {};
+__export(bidiFirefox_exports, {
+  BidiFirefox: () => BidiFirefox
+});
+module.exports = __toCommonJS(bidiFirefox_exports);
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_ascii = require("../utils/ascii");
+var import_browserType = require("../browserType");
+var import_bidiBrowser = require("./bidiBrowser");
+var import_bidiConnection = require("./bidiConnection");
+var import_firefoxPrefs = require("./third_party/firefoxPrefs");
+var import_manualPromise = require("../../utils/isomorphic/manualPromise");
+class BidiFirefox extends import_browserType.BrowserType {
+  constructor(parent) {
+    super(parent, "firefox");
+  }
+  executablePath() {
+    return "";
+  }
+  async connectToTransport(transport, options) {
+    return import_bidiBrowser.BidiBrowser.connect(this.attribution.playwright, transport, options);
+  }
+  doRewriteStartupLog(logs) {
+    if (logs.includes(`as root in a regular user's session is not supported.`))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(`Firefox is unable to launch if the $HOME folder isn't owned by the current user.
+Workaround: Set the HOME=/root environment variable${process.env.GITHUB_ACTION ? " in your GitHub Actions workflow file" : ""} when running Playwright.`, 1);
+    if (logs.includes("no DISPLAY environment variable specified"))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
+    return logs;
+  }
+  amendEnvironment(env) {
+    if (!import_path.default.isAbsolute(import_os.default.homedir()))
+      throw new Error(`Cannot launch Firefox with relative home directory. Did you set ${import_os.default.platform() === "win32" ? "USERPROFILE" : "HOME"} to a relative path?`);
+    env = {
+      ...env,
+      "MOZ_CRASHREPORTER": "1",
+      "MOZ_CRASHREPORTER_NO_REPORT": "1",
+      "MOZ_CRASHREPORTER_SHUTDOWN": "1"
+    };
+    if (import_os.default.platform() === "linux") {
+      return { ...env, SNAP_NAME: void 0, SNAP_INSTANCE_NAME: void 0 };
+    }
+    return env;
+  }
+  attemptToGracefullyCloseBrowser(transport) {
+    this._attemptToGracefullyCloseBrowser(transport).catch(() => {
+    });
+  }
+  async _attemptToGracefullyCloseBrowser(transport) {
+    if (!transport.onmessage) {
+      transport.send({ method: "session.new", params: { capabilities: {} }, id: import_bidiConnection.kShutdownSessionNewMessageId });
+      await new Promise((resolve) => {
+        transport.onmessage = (message) => {
+          if (message.id === import_bidiConnection.kShutdownSessionNewMessageId)
+            resolve(true);
+        };
+      });
+    }
+    transport.send({ method: "browser.close", params: {}, id: import_bidiConnection.kBrowserCloseMessageId });
+  }
+  supportsPipeTransport() {
+    return false;
+  }
+  async prepareUserDataDir(options, userDataDir) {
+    await (0, import_firefoxPrefs.createProfile)({
+      path: userDataDir,
+      preferences: options.firefoxUserPrefs || {}
+    });
+  }
+  async defaultArgs(options, isPersistent, userDataDir) {
+    const { args = [], headless } = options;
+    const userDataDirArg = args.find((arg) => arg.startsWith("-profile") || arg.startsWith("--profile"));
+    if (userDataDirArg)
+      throw this._createUserDataDirArgMisuseError("--profile");
+    if (args.find((arg) => !arg.startsWith("-")))
+      throw new Error("Arguments can not specify page to be opened");
+    const firefoxArguments = ["--remote-debugging-port=0"];
+    if (headless)
+      firefoxArguments.push("--headless");
+    else
+      firefoxArguments.push("--foreground");
+    firefoxArguments.push(`--profile`, userDataDir);
+    firefoxArguments.push(...args);
+    return firefoxArguments;
+  }
+  async waitForReadyState(options, browserLogsCollector) {
+    const result = new import_manualPromise.ManualPromise();
+    browserLogsCollector.onMessage((message) => {
+      const match = message.match(/WebDriver BiDi listening on (ws:\/\/.*)$/);
+      if (match)
+        result.resolve({ wsEndpoint: match[1] + "/session" });
+    });
+    return result;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BidiFirefox
+});

package/lib/server/bidi/bidiInput.js

@@ -0,0 +1,146 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bidiInput_exports = {};
+__export(bidiInput_exports, {
+  RawKeyboardImpl: () => RawKeyboardImpl,
+  RawMouseImpl: () => RawMouseImpl,
+  RawTouchscreenImpl: () => RawTouchscreenImpl
+});
+module.exports = __toCommonJS(bidiInput_exports);
+var import_input = require("../input");
+var import_bidiKeyboard = require("./third_party/bidiKeyboard");
+var bidi = __toESM(require("./third_party/bidiProtocol"));
+class RawKeyboardImpl {
+  constructor(session) {
+    this._session = session;
+  }
+  setSession(session) {
+    this._session = session;
+  }
+  async keydown(progress, modifiers, keyName, description, autoRepeat) {
+    keyName = (0, import_input.resolveSmartModifierString)(keyName);
+    const actions = [];
+    actions.push({ type: "keyDown", value: (0, import_bidiKeyboard.getBidiKeyValue)(keyName) });
+    await this._performActions(progress, actions);
+  }
+  async keyup(progress, modifiers, keyName, description) {
+    keyName = (0, import_input.resolveSmartModifierString)(keyName);
+    const actions = [];
+    actions.push({ type: "keyUp", value: (0, import_bidiKeyboard.getBidiKeyValue)(keyName) });
+    await this._performActions(progress, actions);
+  }
+  async sendText(progress, text) {
+    const actions = [];
+    for (const char of text) {
+      const value = (0, import_bidiKeyboard.getBidiKeyValue)(char);
+      actions.push({ type: "keyDown", value });
+      actions.push({ type: "keyUp", value });
+    }
+    await this._performActions(progress, actions);
+  }
+  async _performActions(progress, actions) {
+    await progress.race(this._session.send("input.performActions", {
+      context: this._session.sessionId,
+      actions: [
+        {
+          type: "key",
+          id: "pw_keyboard",
+          actions
+        }
+      ]
+    }));
+  }
+}
+class RawMouseImpl {
+  constructor(session) {
+    this._session = session;
+  }
+  async move(progress, x, y, button, buttons, modifiers, forClick) {
+    await this._performActions(progress, [{ type: "pointerMove", x, y }]);
+  }
+  async down(progress, x, y, button, buttons, modifiers, clickCount) {
+    await this._performActions(progress, [{ type: "pointerDown", button: toBidiButton(button) }]);
+  }
+  async up(progress, x, y, button, buttons, modifiers, clickCount) {
+    await this._performActions(progress, [{ type: "pointerUp", button: toBidiButton(button) }]);
+  }
+  async wheel(progress, x, y, buttons, modifiers, deltaX, deltaY) {
+    x = Math.floor(x);
+    y = Math.floor(y);
+    await progress.race(this._session.send("input.performActions", {
+      context: this._session.sessionId,
+      actions: [
+        {
+          type: "wheel",
+          id: "pw_mouse_wheel",
+          actions: [{ type: "scroll", x, y, deltaX, deltaY }]
+        }
+      ]
+    }));
+  }
+  async _performActions(progress, actions) {
+    await progress.race(this._session.send("input.performActions", {
+      context: this._session.sessionId,
+      actions: [
+        {
+          type: "pointer",
+          id: "pw_mouse",
+          parameters: {
+            pointerType: bidi.Input.PointerType.Mouse
+          },
+          actions
+        }
+      ]
+    }));
+  }
+}
+class RawTouchscreenImpl {
+  constructor(session) {
+    this._session = session;
+  }
+  async tap(progress, x, y, modifiers) {
+  }
+}
+function toBidiButton(button) {
+  switch (button) {
+    case "left":
+      return 0;
+    case "right":
+      return 2;
+    case "middle":
+      return 1;
+  }
+  throw new Error("Unknown button: " + button);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RawKeyboardImpl,
+  RawMouseImpl,
+  RawTouchscreenImpl
+});