@pedropaulovc/playwright-core 1.59.0-next

package/lib/server/utils/wsServer.js

@@ -0,0 +1,121 @@
+"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 wsServer_exports = {};
+__export(wsServer_exports, {
+  WSServer: () => WSServer,
+  perMessageDeflate: () => perMessageDeflate
+});
+module.exports = __toCommonJS(wsServer_exports);
+var import_network = require("./network");
+var import_utilsBundle = require("../../utilsBundle");
+var import_debugLogger = require("./debugLogger");
+let lastConnectionId = 0;
+const kConnectionSymbol = Symbol("kConnection");
+const perMessageDeflate = {
+  serverNoContextTakeover: true,
+  zlibDeflateOptions: {
+    level: 3
+  },
+  zlibInflateOptions: {
+    chunkSize: 10 * 1024
+  },
+  threshold: 10 * 1024
+};
+class WSServer {
+  constructor(delegate) {
+    this._delegate = delegate;
+  }
+  async listen(port = 0, hostname, path) {
+    import_debugLogger.debugLogger.log("server", `Server started at ${/* @__PURE__ */ new Date()}`);
+    const server = (0, import_network.createHttpServer)(this._delegate.onRequest);
+    server.on("error", (error) => import_debugLogger.debugLogger.log("server", String(error)));
+    this.server = server;
+    const wsEndpoint = await new Promise((resolve, reject) => {
+      server.listen(port, hostname, () => {
+        const address = server.address();
+        if (!address) {
+          reject(new Error("Could not bind server socket"));
+          return;
+        }
+        const wsEndpoint2 = typeof address === "string" ? `${address}${path}` : `ws://${hostname || "localhost"}:${address.port}${path}`;
+        resolve(wsEndpoint2);
+      }).on("error", reject);
+    });
+    import_debugLogger.debugLogger.log("server", "Listening at " + wsEndpoint);
+    this._wsServer = new import_utilsBundle.wsServer({
+      noServer: true,
+      perMessageDeflate
+    });
+    this._wsServer.on("headers", (headers) => this._delegate.onHeaders(headers));
+    server.on("upgrade", (request, socket, head) => {
+      const pathname = new URL("http://localhost" + request.url).pathname;
+      if (pathname !== path) {
+        socket.write(`HTTP/${request.httpVersion} 400 Bad Request\r
+\r
+`);
+        socket.destroy();
+        return;
+      }
+      const upgradeResult = this._delegate.onUpgrade(request, socket);
+      if (upgradeResult) {
+        socket.write(upgradeResult.error);
+        socket.destroy();
+        return;
+      }
+      this._wsServer.handleUpgrade(request, socket, head, (ws) => this._wsServer.emit("connection", ws, request));
+    });
+    this._wsServer.on("connection", (ws, request) => {
+      import_debugLogger.debugLogger.log("server", "Connected client ws.extension=" + ws.extensions);
+      const url = new URL("http://localhost" + (request.url || ""));
+      const id = String(++lastConnectionId);
+      import_debugLogger.debugLogger.log("server", `[${id}] serving connection: ${request.url}`);
+      const connection = this._delegate.onConnection(request, url, ws, id);
+      ws[kConnectionSymbol] = connection;
+    });
+    return wsEndpoint;
+  }
+  async close() {
+    const server = this._wsServer;
+    if (!server)
+      return;
+    import_debugLogger.debugLogger.log("server", "closing websocket server");
+    const waitForClose = new Promise((f) => server.close(f));
+    await Promise.all(Array.from(server.clients).map(async (ws) => {
+      const connection = ws[kConnectionSymbol];
+      if (connection)
+        await connection.close();
+      try {
+        ws.terminate();
+      } catch (e) {
+      }
+    }));
+    await waitForClose;
+    import_debugLogger.debugLogger.log("server", "closing http server");
+    if (this.server)
+      await new Promise((f) => this.server.close(f));
+    this._wsServer = void 0;
+    this.server = void 0;
+    import_debugLogger.debugLogger.log("server", "closed server");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WSServer,
+  perMessageDeflate
+});

package/lib/server/utils/zipFile.js

@@ -0,0 +1,74 @@
+"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 zipFile_exports = {};
+__export(zipFile_exports, {
+  ZipFile: () => ZipFile
+});
+module.exports = __toCommonJS(zipFile_exports);
+var import_zipBundle = require("../../zipBundle");
+class ZipFile {
+  constructor(fileName) {
+    this._entries = /* @__PURE__ */ new Map();
+    this._fileName = fileName;
+    this._openedPromise = this._open();
+  }
+  async _open() {
+    await new Promise((fulfill, reject) => {
+      import_zipBundle.yauzl.open(this._fileName, { autoClose: false }, (e, z) => {
+        if (e) {
+          reject(e);
+          return;
+        }
+        this._zipFile = z;
+        this._zipFile.on("entry", (entry) => {
+          this._entries.set(entry.fileName, entry);
+        });
+        this._zipFile.on("end", fulfill);
+      });
+    });
+  }
+  async entries() {
+    await this._openedPromise;
+    return [...this._entries.keys()];
+  }
+  async read(entryPath) {
+    await this._openedPromise;
+    const entry = this._entries.get(entryPath);
+    if (!entry)
+      throw new Error(`${entryPath} not found in file ${this._fileName}`);
+    return new Promise((resolve, reject) => {
+      this._zipFile.openReadStream(entry, (error, readStream) => {
+        if (error || !readStream) {
+          reject(error || "Entry not found");
+          return;
+        }
+        const buffers = [];
+        readStream.on("data", (data) => buffers.push(data));
+        readStream.on("end", () => resolve(Buffer.concat(buffers)));
+      });
+    });
+  }
+  close() {
+    this._zipFile?.close();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ZipFile
+});

package/lib/server/utils/zones.js

@@ -0,0 +1,57 @@
+"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 zones_exports = {};
+__export(zones_exports, {
+  Zone: () => Zone,
+  currentZone: () => currentZone,
+  emptyZone: () => emptyZone
+});
+module.exports = __toCommonJS(zones_exports);
+var import_async_hooks = require("async_hooks");
+const asyncLocalStorage = new import_async_hooks.AsyncLocalStorage();
+class Zone {
+  constructor(asyncLocalStorage2, store) {
+    this._asyncLocalStorage = asyncLocalStorage2;
+    this._data = store;
+  }
+  with(type, data) {
+    return new Zone(this._asyncLocalStorage, new Map(this._data).set(type, data));
+  }
+  without(type) {
+    const data = type ? new Map(this._data) : /* @__PURE__ */ new Map();
+    data.delete(type);
+    return new Zone(this._asyncLocalStorage, data);
+  }
+  run(func) {
+    return this._asyncLocalStorage.run(this, func);
+  }
+  data(type) {
+    return this._data.get(type);
+  }
+}
+const emptyZone = new Zone(asyncLocalStorage, /* @__PURE__ */ new Map());
+function currentZone() {
+  return asyncLocalStorage.getStore() ?? emptyZone;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Zone,
+  currentZone,
+  emptyZone
+});

package/lib/server/videoRecorder.js

@@ -0,0 +1,124 @@
+"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 videoRecorder_exports = {};
+__export(videoRecorder_exports, {
+  VideoRecorder: () => VideoRecorder
+});
+module.exports = __toCommonJS(videoRecorder_exports);
+var import_utils = require("../utils");
+var import_processLauncher = require("./utils/processLauncher");
+const fps = 25;
+class VideoRecorder {
+  constructor(ffmpegPath, options) {
+    this._process = null;
+    this._gracefullyClose = null;
+    this._lastWritePromise = Promise.resolve();
+    this._firstFrameTimestamp = 0;
+    this._lastFrame = null;
+    this._lastWriteNodeTime = 0;
+    this._frameQueue = [];
+    this._isStopped = false;
+    this._ffmpegPath = ffmpegPath;
+    if (!options.outputFile.endsWith(".webm"))
+      throw new Error("File must have .webm extension");
+    this._launchPromise = this._launch(options).catch((e) => e);
+  }
+  async _launch(options) {
+    await (0, import_utils.mkdirIfNeeded)(options.outputFile);
+    const w = options.width;
+    const h = options.height;
+    const args = `-loglevel error -f image2pipe -avioflags direct -fpsprobesize 0 -probesize 32 -analyzeduration 0 -c:v mjpeg -i pipe:0 -y -an -r ${fps} -c:v vp8 -qmin 0 -qmax 50 -crf 8 -deadline realtime -speed 8 -b:v 1M -threads 1 -vf pad=${w}:${h}:0:0:gray,crop=${w}:${h}:0:0`.split(" ");
+    args.push(options.outputFile);
+    const { launchedProcess, gracefullyClose } = await (0, import_processLauncher.launchProcess)({
+      command: this._ffmpegPath,
+      args,
+      stdio: "stdin",
+      log: (message) => import_utils.debugLogger.log("browser", message),
+      tempDirectories: [],
+      attemptToGracefullyClose: async () => {
+        import_utils.debugLogger.log("browser", "Closing stdin...");
+        launchedProcess.stdin.end();
+      },
+      onExit: (exitCode, signal) => {
+        import_utils.debugLogger.log("browser", `ffmpeg onkill exitCode=${exitCode} signal=${signal}`);
+      }
+    });
+    launchedProcess.stdin.on("finish", () => {
+      import_utils.debugLogger.log("browser", "ffmpeg finished input.");
+    });
+    launchedProcess.stdin.on("error", () => {
+      import_utils.debugLogger.log("browser", "ffmpeg error.");
+    });
+    this._process = launchedProcess;
+    this._gracefullyClose = gracefullyClose;
+  }
+  writeFrame(frame, timestamp) {
+    this._launchPromise.then((error) => {
+      if (error)
+        return;
+      this._writeFrame(frame, timestamp);
+    });
+  }
+  _writeFrame(frame, timestamp) {
+    (0, import_utils.assert)(this._process);
+    if (this._isStopped)
+      return;
+    if (!this._firstFrameTimestamp)
+      this._firstFrameTimestamp = timestamp;
+    const frameNumber = Math.floor((timestamp - this._firstFrameTimestamp) * fps);
+    if (this._lastFrame) {
+      const repeatCount = frameNumber - this._lastFrame.frameNumber;
+      for (let i = 0; i < repeatCount; ++i)
+        this._frameQueue.push(this._lastFrame.buffer);
+      this._lastWritePromise = this._lastWritePromise.then(() => this._sendFrames());
+    }
+    this._lastFrame = { buffer: frame, timestamp, frameNumber };
+    this._lastWriteNodeTime = (0, import_utils.monotonicTime)();
+  }
+  async _sendFrames() {
+    while (this._frameQueue.length)
+      await this._sendFrame(this._frameQueue.shift());
+  }
+  async _sendFrame(frame) {
+    return new Promise((f) => this._process.stdin.write(frame, f)).then((error) => {
+      if (error)
+        import_utils.debugLogger.log("browser", `ffmpeg failed to write: ${String(error)}`);
+    });
+  }
+  async stop() {
+    const error = await this._launchPromise;
+    if (error)
+      throw error;
+    if (this._isStopped || !this._lastFrame)
+      return;
+    const addTime = Math.max(((0, import_utils.monotonicTime)() - this._lastWriteNodeTime) / 1e3, 1);
+    this._writeFrame(Buffer.from([]), this._lastFrame.timestamp + addTime);
+    this._isStopped = true;
+    try {
+      await this._lastWritePromise;
+      await this._gracefullyClose();
+    } catch (e) {
+      import_utils.debugLogger.log("error", `ffmpeg failed to stop: ${String(e)}`);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VideoRecorder
+});

package/lib/server/webkit/protocol.d.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 protocol_d_exports = {};
+module.exports = __toCommonJS(protocol_d_exports);

package/lib/server/webkit/webkit.js

@@ -0,0 +1,108 @@
+"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 webkit_exports = {};
+__export(webkit_exports, {
+  WebKit: () => WebKit,
+  translatePathToWSL: () => translatePathToWSL
+});
+module.exports = __toCommonJS(webkit_exports);
+var import_path = __toESM(require("path"));
+var import_wkConnection = require("./wkConnection");
+var import_ascii = require("../utils/ascii");
+var import_browserType = require("../browserType");
+var import_wkBrowser = require("../webkit/wkBrowser");
+var import_spawnAsync = require("../utils/spawnAsync");
+class WebKit extends import_browserType.BrowserType {
+  constructor(parent) {
+    super(parent, "webkit");
+  }
+  connectToTransport(transport, options) {
+    return import_wkBrowser.WKBrowser.connect(this.attribution.playwright, transport, options);
+  }
+  amendEnvironment(env, userDataDir, isPersistent, options) {
+    return {
+      ...env,
+      CURL_COOKIE_JAR_PATH: process.platform === "win32" && isPersistent ? import_path.default.join(userDataDir, "cookiejar.db") : void 0
+    };
+  }
+  doRewriteStartupLog(logs) {
+    if (logs.includes("Failed to open display") || logs.includes("cannot open display"))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
+    return logs;
+  }
+  attemptToGracefullyCloseBrowser(transport) {
+    transport.send({ method: "Playwright.close", params: {}, id: import_wkConnection.kBrowserCloseMessageId });
+  }
+  async defaultArgs(options, isPersistent, userDataDir) {
+    const { args = [], headless } = options;
+    const userDataDirArg = args.find((arg) => arg.startsWith("--user-data-dir"));
+    if (userDataDirArg)
+      throw this._createUserDataDirArgMisuseError("--user-data-dir");
+    if (args.find((arg) => !arg.startsWith("-")))
+      throw new Error("Arguments can not specify page to be opened");
+    const webkitArguments = ["--inspector-pipe"];
+    if (process.platform === "win32" && options.channel !== "webkit-wsl")
+      webkitArguments.push("--disable-accelerated-compositing");
+    if (headless)
+      webkitArguments.push("--headless");
+    if (isPersistent)
+      webkitArguments.push(`--user-data-dir=${options.channel === "webkit-wsl" ? await translatePathToWSL(userDataDir) : userDataDir}`);
+    else
+      webkitArguments.push(`--no-startup-window`);
+    const proxy = options.proxyOverride || options.proxy;
+    if (proxy) {
+      if (process.platform === "darwin") {
+        webkitArguments.push(`--proxy=${proxy.server}`);
+        if (proxy.bypass)
+          webkitArguments.push(`--proxy-bypass-list=${proxy.bypass}`);
+      } else if (process.platform === "linux" || process.platform === "win32" && options.channel === "webkit-wsl") {
+        webkitArguments.push(`--proxy=${proxy.server}`);
+        if (proxy.bypass)
+          webkitArguments.push(...proxy.bypass.split(",").map((t) => `--ignore-host=${t}`));
+      } else if (process.platform === "win32") {
+        webkitArguments.push(`--curl-proxy=${proxy.server.replace(/^socks5:\/\//, "socks5h://")}`);
+        if (proxy.bypass)
+          webkitArguments.push(`--curl-noproxy=${proxy.bypass}`);
+      }
+    }
+    webkitArguments.push(...args);
+    if (isPersistent)
+      webkitArguments.push("about:blank");
+    return webkitArguments;
+  }
+}
+async function translatePathToWSL(path2) {
+  const { stdout } = await (0, import_spawnAsync.spawnAsync)("wsl.exe", ["-d", "playwright", "--cd", "/home/pwuser", "wslpath", path2.replace(/\\/g, "\\\\")]);
+  return stdout.toString().trim();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebKit,
+  translatePathToWSL
+});