@stablyai/internal-playwright-core 0.1.0

package/lib/client/webError.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 webError_exports = {};
+__export(webError_exports, {
+  WebError: () => WebError
+});
+module.exports = __toCommonJS(webError_exports);
+class WebError {
+  constructor(page, error) {
+    this._page = page;
+    this._error = error;
+  }
+  page() {
+    return this._page;
+  }
+  error() {
+    return this._error;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebError
+});

package/lib/client/webSocket.js

@@ -0,0 +1,93 @@
+"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 webSocket_exports = {};
+__export(webSocket_exports, {
+  connectOverWebSocket: () => connectOverWebSocket
+});
+module.exports = __toCommonJS(webSocket_exports);
+var import_connection = require("./connection");
+async function connectOverWebSocket(parentConnection, params) {
+  const localUtils = parentConnection.localUtils();
+  const transport = localUtils ? new JsonPipeTransport(localUtils) : new WebSocketTransport();
+  const connectHeaders = await transport.connect(params);
+  const connection = new import_connection.Connection(parentConnection._platform, localUtils, parentConnection._instrumentation, connectHeaders);
+  connection.markAsRemote();
+  connection.on("close", () => transport.close());
+  let closeError;
+  const onTransportClosed = (reason) => {
+    connection.close(reason || closeError);
+  };
+  transport.onClose((reason) => onTransportClosed(reason));
+  connection.onmessage = (message) => transport.send(message).catch(() => onTransportClosed());
+  transport.onMessage((message) => {
+    try {
+      connection.dispatch(message);
+    } catch (e) {
+      closeError = String(e);
+      transport.close().catch(() => {
+      });
+    }
+  });
+  return connection;
+}
+class JsonPipeTransport {
+  constructor(owner) {
+    this._owner = owner;
+  }
+  async connect(params) {
+    const { pipe, headers: connectHeaders } = await this._owner._channel.connect(params);
+    this._pipe = pipe;
+    return connectHeaders;
+  }
+  async send(message) {
+    await this._pipe.send({ message });
+  }
+  onMessage(callback) {
+    this._pipe.on("message", ({ message }) => callback(message));
+  }
+  onClose(callback) {
+    this._pipe.on("closed", ({ reason }) => callback(reason));
+  }
+  async close() {
+    await this._pipe.close().catch(() => {
+    });
+  }
+}
+class WebSocketTransport {
+  async connect(params) {
+    this._ws = new window.WebSocket(params.wsEndpoint);
+    return [];
+  }
+  async send(message) {
+    this._ws.send(JSON.stringify(message));
+  }
+  onMessage(callback) {
+    this._ws.addEventListener("message", (event) => callback(JSON.parse(event.data)));
+  }
+  onClose(callback) {
+    this._ws.addEventListener("close", () => callback());
+  }
+  async close() {
+    this._ws.close();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  connectOverWebSocket
+});

package/lib/client/worker.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 worker_exports = {};
+__export(worker_exports, {
+  Worker: () => Worker
+});
+module.exports = __toCommonJS(worker_exports);
+var import_channelOwner = require("./channelOwner");
+var import_errors = require("./errors");
+var import_events = require("./events");
+var import_jsHandle = require("./jsHandle");
+var import_manualPromise = require("../utils/isomorphic/manualPromise");
+class Worker extends import_channelOwner.ChannelOwner {
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    // Set for service workers.
+    this._closedScope = new import_manualPromise.LongStandingScope();
+    this._channel.on("close", () => {
+      if (this._page)
+        this._page._workers.delete(this);
+      if (this._context)
+        this._context._serviceWorkers.delete(this);
+      this.emit(import_events.Events.Worker.Close, this);
+    });
+    this.once(import_events.Events.Worker.Close, () => this._closedScope.close(this._page?._closeErrorWithReason() || new import_errors.TargetClosedError()));
+  }
+  static from(worker) {
+    return worker._object;
+  }
+  url() {
+    return this._initializer.url;
+  }
+  async evaluate(pageFunction, arg) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
+    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
+    return (0, import_jsHandle.parseResult)(result.value);
+  }
+  async evaluateHandle(pageFunction, arg) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
+    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
+    return import_jsHandle.JSHandle.from(result.handle);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Worker
+});

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

package/lib/common/debugLogger.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.debugLogger = exports.RecentLogsCollector = void 0;
+var _utilsBundle = require("../utilsBundle");
+var _fs = _interopRequireDefault(require("fs"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const debugLoggerColorMap = {
+  'api': 45,
+  // cyan
+  'protocol': 34,
+  // green
+  'install': 34,
+  // green
+  'download': 34,
+  // green
+  'browser': 0,
+  // reset
+  'socks': 92,
+  // purple
+  'error': 160,
+  // red,
+  'channel': 33,
+  // blue
+  'server': 45,
+  // cyan
+  'server:channel': 34,
+  // green
+  'server:metadata': 33 // blue
+};
+
+class DebugLogger {
+  constructor() {
+    this._debuggers = new Map();
+    if (process.env.DEBUG_FILE) {
+      const ansiRegex = new RegExp(['[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)', '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'].join('|'), 'g');
+      const stream = _fs.default.createWriteStream(process.env.DEBUG_FILE);
+      _utilsBundle.debug.log = data => {
+        stream.write(data.replace(ansiRegex, ''));
+        stream.write('\n');
+      };
+    }
+  }
+  log(name, message) {
+    let cachedDebugger = this._debuggers.get(name);
+    if (!cachedDebugger) {
+      cachedDebugger = (0, _utilsBundle.debug)(`pw:${name}`);
+      this._debuggers.set(name, cachedDebugger);
+      cachedDebugger.color = debugLoggerColorMap[name] || 0;
+    }
+    cachedDebugger(message);
+  }
+  isEnabled(name) {
+    return _utilsBundle.debug.enabled(`pw:${name}`);
+  }
+}
+const debugLogger = exports.debugLogger = new DebugLogger();
+const kLogCount = 150;
+class RecentLogsCollector {
+  constructor() {
+    this._logs = [];
+  }
+  log(message) {
+    this._logs.push(message);
+    if (this._logs.length === kLogCount * 2) this._logs.splice(0, kLogCount);
+  }
+  recentLogs() {
+    if (this._logs.length > kLogCount) return this._logs.slice(-kLogCount);
+    return this._logs;
+  }
+}
+exports.RecentLogsCollector = RecentLogsCollector;