@pedropaulovc/playwright-core 1.59.0-next

package/lib/server/pipeTransport.js

@@ -0,0 +1,89 @@
+"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 pipeTransport_exports = {};
+__export(pipeTransport_exports, {
+  PipeTransport: () => PipeTransport
+});
+module.exports = __toCommonJS(pipeTransport_exports);
+var import_utils = require("../utils");
+var import_debugLogger = require("./utils/debugLogger");
+class PipeTransport {
+  constructor(pipeWrite, pipeRead) {
+    this._pendingBuffers = [];
+    this._waitForNextTask = (0, import_utils.makeWaitForNextTask)();
+    this._closed = false;
+    this._pipeRead = pipeRead;
+    this._pipeWrite = pipeWrite;
+    pipeRead.on("data", (buffer) => this._dispatch(buffer));
+    pipeRead.on("close", () => {
+      this._closed = true;
+      if (this._onclose)
+        this._onclose.call(null);
+    });
+    pipeRead.on("error", (e) => import_debugLogger.debugLogger.log("error", e));
+    pipeWrite.on("error", (e) => import_debugLogger.debugLogger.log("error", e));
+    this.onmessage = void 0;
+  }
+  get onclose() {
+    return this._onclose;
+  }
+  set onclose(onclose) {
+    this._onclose = onclose;
+    if (onclose && !this._pipeRead.readable)
+      onclose();
+  }
+  send(message) {
+    if (this._closed)
+      throw new Error("Pipe has been closed");
+    this._pipeWrite.write(JSON.stringify(message));
+    this._pipeWrite.write("\0");
+  }
+  close() {
+    throw new Error("unimplemented");
+  }
+  _dispatch(buffer) {
+    let end = buffer.indexOf("\0");
+    if (end === -1) {
+      this._pendingBuffers.push(buffer);
+      return;
+    }
+    this._pendingBuffers.push(buffer.slice(0, end));
+    const message = Buffer.concat(this._pendingBuffers).toString();
+    this._waitForNextTask(() => {
+      if (this.onmessage)
+        this.onmessage.call(null, JSON.parse(message));
+    });
+    let start = end + 1;
+    end = buffer.indexOf("\0", start);
+    while (end !== -1) {
+      const message2 = buffer.toString(void 0, start, end);
+      this._waitForNextTask(() => {
+        if (this.onmessage)
+          this.onmessage.call(null, JSON.parse(message2));
+      });
+      start = end + 1;
+      end = buffer.indexOf("\0", start);
+    }
+    this._pendingBuffers = [buffer.slice(start)];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PipeTransport
+});

package/lib/server/playwright.js

@@ -0,0 +1,69 @@
+"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,
+  createPlaywright: () => createPlaywright
+});
+module.exports = __toCommonJS(playwright_exports);
+var import_android = require("./android/android");
+var import_backendAdb = require("./android/backendAdb");
+var import_bidiChromium = require("./bidi/bidiChromium");
+var import_bidiFirefox = require("./bidi/bidiFirefox");
+var import_chromium = require("./chromium/chromium");
+var import_debugController = require("./debugController");
+var import_electron = require("./electron/electron");
+var import_firefox = require("./firefox/firefox");
+var import_instrumentation = require("./instrumentation");
+var import_webkit = require("./webkit/webkit");
+class Playwright extends import_instrumentation.SdkObject {
+  constructor(options) {
+    super((0, import_instrumentation.createRootSdkObject)(), void 0, "Playwright");
+    this._allPages = /* @__PURE__ */ new Set();
+    this._allBrowsers = /* @__PURE__ */ new Set();
+    this.options = options;
+    this.attribution.playwright = this;
+    this.instrumentation.addListener({
+      onBrowserOpen: (browser) => this._allBrowsers.add(browser),
+      onBrowserClose: (browser) => this._allBrowsers.delete(browser),
+      onPageOpen: (page) => this._allPages.add(page),
+      onPageClose: (page) => this._allPages.delete(page)
+    }, null);
+    this.chromium = new import_chromium.Chromium(this, new import_bidiChromium.BidiChromium(this));
+    this.firefox = new import_firefox.Firefox(this, new import_bidiFirefox.BidiFirefox(this));
+    this.webkit = new import_webkit.WebKit(this);
+    this.electron = new import_electron.Electron(this);
+    this.android = new import_android.Android(this, new import_backendAdb.AdbBackend());
+    this.debugController = new import_debugController.DebugController(this);
+  }
+  allBrowsers() {
+    return [...this._allBrowsers];
+  }
+  allPages() {
+    return [...this._allPages];
+  }
+}
+function createPlaywright(options) {
+  return new Playwright(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Playwright,
+  createPlaywright
+});

package/lib/server/progress.js

@@ -0,0 +1,132 @@
+"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 progress_exports = {};
+__export(progress_exports, {
+  ProgressController: () => ProgressController,
+  isAbortError: () => isAbortError,
+  raceUncancellableOperationWithCleanup: () => raceUncancellableOperationWithCleanup
+});
+module.exports = __toCommonJS(progress_exports);
+var import_errors = require("./errors");
+var import_utils = require("../utils");
+var import_manualPromise = require("../utils/isomorphic/manualPromise");
+class ProgressController {
+  constructor(metadata, onCallLog) {
+    this._forceAbortPromise = new import_manualPromise.ManualPromise();
+    this._donePromise = new import_manualPromise.ManualPromise();
+    this._state = "before";
+    this.metadata = metadata || { id: "", startTime: 0, endTime: 0, type: "Internal", method: "", params: {}, log: [], internal: true };
+    this._onCallLog = onCallLog;
+    this._forceAbortPromise.catch((e) => null);
+    this._controller = new AbortController();
+  }
+  static createForSdkObject(sdkObject, callMetadata) {
+    const logName = sdkObject.logName || "api";
+    return new ProgressController(callMetadata, (message) => {
+      import_utils.debugLogger.log(logName, message);
+      sdkObject.instrumentation.onCallLog(sdkObject, callMetadata, logName, message);
+    });
+  }
+  async abort(error) {
+    if (this._state === "running") {
+      error[kAbortErrorSymbol] = true;
+      this._state = { error };
+      this._forceAbortPromise.reject(error);
+      this._controller.abort(error);
+    }
+    await this._donePromise;
+  }
+  async run(task, timeout) {
+    const deadline = timeout ? (0, import_utils.monotonicTime)() + timeout : 0;
+    (0, import_utils.assert)(this._state === "before");
+    this._state = "running";
+    let timer;
+    const progress = {
+      timeout: timeout ?? 0,
+      deadline,
+      disableTimeout: () => {
+        clearTimeout(timer);
+      },
+      log: (message) => {
+        if (this._state === "running")
+          this.metadata.log.push(message);
+        this._onCallLog?.(message);
+      },
+      metadata: this.metadata,
+      race: (promise) => {
+        const promises = Array.isArray(promise) ? promise : [promise];
+        if (!promises.length)
+          return Promise.resolve();
+        return Promise.race([...promises, this._forceAbortPromise]);
+      },
+      wait: async (timeout2) => {
+        let timer2;
+        const promise = new Promise((f) => timer2 = setTimeout(f, timeout2));
+        return progress.race(promise).finally(() => clearTimeout(timer2));
+      },
+      signal: this._controller.signal
+    };
+    if (deadline) {
+      const timeoutError = new import_errors.TimeoutError(`Timeout ${timeout}ms exceeded.`);
+      timer = setTimeout(() => {
+        if (this.metadata.pauseStartTime && !this.metadata.pauseEndTime)
+          return;
+        if (this._state === "running") {
+          this._state = { error: timeoutError };
+          this._forceAbortPromise.reject(timeoutError);
+          this._controller.abort(timeoutError);
+        }
+      }, deadline - (0, import_utils.monotonicTime)());
+    }
+    try {
+      const result = await task(progress);
+      this._state = "finished";
+      return result;
+    } catch (error) {
+      this._state = { error };
+      throw error;
+    } finally {
+      clearTimeout(timer);
+      this._donePromise.resolve();
+    }
+  }
+}
+const kAbortErrorSymbol = Symbol("kAbortError");
+function isAbortError(error) {
+  return error instanceof import_errors.TimeoutError || !!error[kAbortErrorSymbol];
+}
+async function raceUncancellableOperationWithCleanup(progress, run, cleanup) {
+  let aborted = false;
+  try {
+    return await progress.race(run().then(async (t) => {
+      if (aborted)
+        await cleanup(t);
+      return t;
+    }));
+  } catch (error) {
+    aborted = true;
+    throw error;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProgressController,
+  isAbortError,
+  raceUncancellableOperationWithCleanup
+});

package/lib/server/protocolError.js

@@ -0,0 +1,52 @@
+"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 protocolError_exports = {};
+__export(protocolError_exports, {
+  ProtocolError: () => ProtocolError,
+  isProtocolError: () => isProtocolError,
+  isSessionClosedError: () => isSessionClosedError
+});
+module.exports = __toCommonJS(protocolError_exports);
+var import_stackTrace = require("../utils/isomorphic/stackTrace");
+class ProtocolError extends Error {
+  constructor(type, method, logs) {
+    super();
+    this.type = type;
+    this.method = method;
+    this.logs = logs;
+  }
+  setMessage(message) {
+    (0, import_stackTrace.rewriteErrorMessage)(this, `Protocol error (${this.method}): ${message}`);
+  }
+  browserLogMessage() {
+    return this.logs ? "\nBrowser logs:\n" + this.logs : "";
+  }
+}
+function isProtocolError(e) {
+  return e instanceof ProtocolError;
+}
+function isSessionClosedError(e) {
+  return e instanceof ProtocolError && (e.type === "closed" || e.type === "crashed");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProtocolError,
+  isProtocolError,
+  isSessionClosedError
+});

package/lib/server/recorder/chat.js

@@ -0,0 +1,161 @@
+"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 chat_exports = {};
+__export(chat_exports, {
+  Chat: () => Chat,
+  asString: () => asString
+});
+module.exports = __toCommonJS(chat_exports);
+var import_transport = require("../transport");
+class Chat {
+  constructor(wsEndpoint) {
+    this._history = [];
+    this._chatSinks = /* @__PURE__ */ new Map();
+    this._wsEndpoint = wsEndpoint;
+  }
+  clearHistory() {
+    this._history = [];
+  }
+  async post(prompt) {
+    await this._append("user", prompt);
+    let text = await asString(await this._post());
+    if (text.startsWith("```json") && text.endsWith("```"))
+      text = text.substring("```json".length, text.length - "```".length);
+    for (let i = 0; i < 3; ++i) {
+      try {
+        return JSON.parse(text);
+      } catch (e) {
+        await this._append("user", String(e));
+      }
+    }
+    throw new Error("Failed to parse response: " + text);
+  }
+  async _append(user, content) {
+    this._history.push({ user, content });
+  }
+  async _connection() {
+    if (!this._connectionPromise) {
+      this._connectionPromise = import_transport.WebSocketTransport.connect(void 0, this._wsEndpoint).then((transport) => {
+        return new Connection(transport, (method, params) => this._dispatchEvent(method, params), () => {
+        });
+      });
+    }
+    return this._connectionPromise;
+  }
+  _dispatchEvent(method, params) {
+    if (method === "chatChunk") {
+      const { chatId, chunk } = params;
+      const chunkSink = this._chatSinks.get(chatId);
+      chunkSink(chunk);
+      if (!chunk)
+        this._chatSinks.delete(chatId);
+    }
+  }
+  async _post() {
+    const connection = await this._connection();
+    const result = await connection.send("chat", { history: this._history });
+    const { chatId } = result;
+    const { iterable, addChunk } = iterablePump();
+    this._chatSinks.set(chatId, addChunk);
+    return iterable;
+  }
+}
+async function asString(stream) {
+  let result = "";
+  for await (const chunk of stream)
+    result += chunk;
+  return result;
+}
+function iterablePump() {
+  let controller;
+  const stream = new ReadableStream({ start: (c) => controller = c });
+  const iterable = (async function* () {
+    const reader = stream.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      yield value;
+    }
+  })();
+  return {
+    iterable,
+    addChunk: (chunk) => {
+      if (chunk)
+        controller.enqueue(chunk);
+      else
+        controller.close();
+    }
+  };
+}
+class Connection {
+  constructor(transport, onEvent, onClose) {
+    this._lastId = 0;
+    this._closed = false;
+    this._pending = /* @__PURE__ */ new Map();
+    this._transport = transport;
+    this._onEvent = onEvent;
+    this._onClose = onClose;
+    this._transport.onmessage = this._dispatchMessage.bind(this);
+    this._transport.onclose = this._close.bind(this);
+  }
+  send(method, params) {
+    const id = this._lastId++;
+    const message = { id, method, params };
+    this._transport.send(message);
+    return new Promise((resolve, reject) => {
+      this._pending.set(id, { resolve, reject });
+    });
+  }
+  _dispatchMessage(message) {
+    if (message.id === void 0) {
+      this._onEvent(message.method, message.params);
+      return;
+    }
+    const callback = this._pending.get(message.id);
+    this._pending.delete(message.id);
+    if (!callback)
+      return;
+    if (message.error) {
+      callback.reject(new Error(message.error.message));
+      return;
+    }
+    callback.resolve(message.result);
+  }
+  _close() {
+    this._closed = true;
+    this._transport.onmessage = void 0;
+    this._transport.onclose = void 0;
+    for (const { reject } of this._pending.values())
+      reject(new Error("Connection closed"));
+    this._onClose();
+  }
+  isClosed() {
+    return this._closed;
+  }
+  close() {
+    if (!this._closed)
+      this._transport.close();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Chat,
+  asString
+});