patchright-bun 1.58.1 → 1.58.2

package/lib/runner/sigIntWatcher.js

@@ -1,96 +1,96 @@
-"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 sigIntWatcher_exports = {};
-__export(sigIntWatcher_exports, {
-  SigIntWatcher: () => SigIntWatcher
-});
-module.exports = __toCommonJS(sigIntWatcher_exports);
-class SigIntWatcher {
-  constructor() {
-    this._hadSignal = false;
-    let sigintCallback;
-    this._sigintPromise = new Promise((f) => sigintCallback = f);
-    this._sigintHandler = () => {
-      FixedNodeSIGINTHandler.off(this._sigintHandler);
-      this._hadSignal = true;
-      sigintCallback();
-    };
-    FixedNodeSIGINTHandler.on(this._sigintHandler);
-  }
-  promise() {
-    return this._sigintPromise;
-  }
-  hadSignal() {
-    return this._hadSignal;
-  }
-  disarm() {
-    FixedNodeSIGINTHandler.off(this._sigintHandler);
-  }
-}
-class FixedNodeSIGINTHandler {
-  static {
-    this._handlers = [];
-  }
-  static {
-    this._ignoreNextSIGINTs = false;
-  }
-  static {
-    this._handlerInstalled = false;
-  }
-  static {
-    this._dispatch = () => {
-      if (this._ignoreNextSIGINTs)
-        return;
-      this._ignoreNextSIGINTs = true;
-      setTimeout(() => {
-        this._ignoreNextSIGINTs = false;
-        if (!this._handlers.length)
-          this._uninstall();
-      }, 1e3);
-      for (const handler of this._handlers)
-        handler();
-    };
-  }
-  static _install() {
-    if (!this._handlerInstalled) {
-      this._handlerInstalled = true;
-      process.on("SIGINT", this._dispatch);
-    }
-  }
-  static _uninstall() {
-    if (this._handlerInstalled) {
-      this._handlerInstalled = false;
-      process.off("SIGINT", this._dispatch);
-    }
-  }
-  static on(handler) {
-    this._handlers.push(handler);
-    if (this._handlers.length === 1)
-      this._install();
-  }
-  static off(handler) {
-    this._handlers = this._handlers.filter((h) => h !== handler);
-    if (!this._ignoreNextSIGINTs && !this._handlers.length)
-      this._uninstall();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  SigIntWatcher
-});
+"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 sigIntWatcher_exports = {};
+__export(sigIntWatcher_exports, {
+  SigIntWatcher: () => SigIntWatcher
+});
+module.exports = __toCommonJS(sigIntWatcher_exports);
+class SigIntWatcher {
+  constructor() {
+    this._hadSignal = false;
+    let sigintCallback;
+    this._sigintPromise = new Promise((f) => sigintCallback = f);
+    this._sigintHandler = () => {
+      FixedNodeSIGINTHandler.off(this._sigintHandler);
+      this._hadSignal = true;
+      sigintCallback();
+    };
+    FixedNodeSIGINTHandler.on(this._sigintHandler);
+  }
+  promise() {
+    return this._sigintPromise;
+  }
+  hadSignal() {
+    return this._hadSignal;
+  }
+  disarm() {
+    FixedNodeSIGINTHandler.off(this._sigintHandler);
+  }
+}
+class FixedNodeSIGINTHandler {
+  static {
+    this._handlers = [];
+  }
+  static {
+    this._ignoreNextSIGINTs = false;
+  }
+  static {
+    this._handlerInstalled = false;
+  }
+  static {
+    this._dispatch = () => {
+      if (this._ignoreNextSIGINTs)
+        return;
+      this._ignoreNextSIGINTs = true;
+      setTimeout(() => {
+        this._ignoreNextSIGINTs = false;
+        if (!this._handlers.length)
+          this._uninstall();
+      }, 1e3);
+      for (const handler of this._handlers)
+        handler();
+    };
+  }
+  static _install() {
+    if (!this._handlerInstalled) {
+      this._handlerInstalled = true;
+      process.on("SIGINT", this._dispatch);
+    }
+  }
+  static _uninstall() {
+    if (this._handlerInstalled) {
+      this._handlerInstalled = false;
+      process.off("SIGINT", this._dispatch);
+    }
+  }
+  static on(handler) {
+    this._handlers.push(handler);
+    if (this._handlers.length === 1)
+      this._install();
+  }
+  static off(handler) {
+    this._handlers = this._handlers.filter((h) => h !== handler);
+    if (!this._ignoreNextSIGINTs && !this._handlers.length)
+      this._uninstall();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SigIntWatcher
+});

package/lib/runner/storage.js

@@ -1,91 +1,91 @@
-"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 storage_exports = {};
-__export(storage_exports, {
-  Storage: () => Storage
-});
-module.exports = __toCommonJS(storage_exports);
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-var import_utils = require("patchright-core/lib/utils");
-class Storage {
-  static {
-    this._storages = /* @__PURE__ */ new Map();
-  }
-  static {
-    this._serializeQueue = Promise.resolve();
-  }
-  static clone(storageFile, outputDir) {
-    return Storage._withStorage(storageFile, (storage) => storage._clone(outputDir));
-  }
-  static upstream(storageFile, storageOutFile) {
-    return Storage._withStorage(storageFile, (storage) => storage._upstream(storageOutFile));
-  }
-  static _withStorage(fileName, runnable) {
-    this._serializeQueue = this._serializeQueue.then(() => {
-      let storage = Storage._storages.get(fileName);
-      if (!storage) {
-        storage = new Storage(fileName);
-        Storage._storages.set(fileName, storage);
-      }
-      return runnable(storage);
-    });
-    return this._serializeQueue;
-  }
-  constructor(fileName) {
-    this._fileName = fileName;
-  }
-  async _clone(outputDir) {
-    const entries = await this._load();
-    if (this._lastSnapshotFileName)
-      return this._lastSnapshotFileName;
-    const snapshotFile = import_path.default.join(outputDir, `pw-storage-${(0, import_utils.createGuid)()}.json`);
-    await import_fs.default.promises.writeFile(snapshotFile, JSON.stringify(entries, null, 2)).catch(() => {
-    });
-    this._lastSnapshotFileName = snapshotFile;
-    return snapshotFile;
-  }
-  async _upstream(storageOutFile) {
-    const entries = await this._load();
-    const newEntries = await import_fs.default.promises.readFile(storageOutFile, "utf8").then(JSON.parse).catch(() => ({}));
-    for (const [key, newValue] of Object.entries(newEntries))
-      entries[key] = newValue;
-    this._lastSnapshotFileName = void 0;
-    await import_fs.default.promises.writeFile(this._fileName, JSON.stringify(entries, null, 2));
-  }
-  async _load() {
-    if (!this._entriesPromise)
-      this._entriesPromise = import_fs.default.promises.readFile(this._fileName, "utf8").then(JSON.parse).catch(() => ({}));
-    return this._entriesPromise;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Storage
-});
+"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 storage_exports = {};
+__export(storage_exports, {
+  Storage: () => Storage
+});
+module.exports = __toCommonJS(storage_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utils = require("patchright-bun-core/lib/utils");
+class Storage {
+  static {
+    this._storages = /* @__PURE__ */ new Map();
+  }
+  static {
+    this._serializeQueue = Promise.resolve();
+  }
+  static clone(storageFile, outputDir) {
+    return Storage._withStorage(storageFile, (storage) => storage._clone(outputDir));
+  }
+  static upstream(storageFile, storageOutFile) {
+    return Storage._withStorage(storageFile, (storage) => storage._upstream(storageOutFile));
+  }
+  static _withStorage(fileName, runnable) {
+    this._serializeQueue = this._serializeQueue.then(() => {
+      let storage = Storage._storages.get(fileName);
+      if (!storage) {
+        storage = new Storage(fileName);
+        Storage._storages.set(fileName, storage);
+      }
+      return runnable(storage);
+    });
+    return this._serializeQueue;
+  }
+  constructor(fileName) {
+    this._fileName = fileName;
+  }
+  async _clone(outputDir) {
+    const entries = await this._load();
+    if (this._lastSnapshotFileName)
+      return this._lastSnapshotFileName;
+    const snapshotFile = import_path.default.join(outputDir, `pw-storage-${(0, import_utils.createGuid)()}.json`);
+    await import_fs.default.promises.writeFile(snapshotFile, JSON.stringify(entries, null, 2)).catch(() => {
+    });
+    this._lastSnapshotFileName = snapshotFile;
+    return snapshotFile;
+  }
+  async _upstream(storageOutFile) {
+    const entries = await this._load();
+    const newEntries = await import_fs.default.promises.readFile(storageOutFile, "utf8").then(JSON.parse).catch(() => ({}));
+    for (const [key, newValue] of Object.entries(newEntries))
+      entries[key] = newValue;
+    this._lastSnapshotFileName = void 0;
+    await import_fs.default.promises.writeFile(this._fileName, JSON.stringify(entries, null, 2));
+  }
+  async _load() {
+    if (!this._entriesPromise)
+      this._entriesPromise = import_fs.default.promises.readFile(this._fileName, "utf8").then(JSON.parse).catch(() => ({}));
+    return this._entriesPromise;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Storage
+});

package/lib/runner/taskRunner.js

@@ -1,127 +1,127 @@
-"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 taskRunner_exports = {};
-__export(taskRunner_exports, {
-  TaskRunner: () => TaskRunner
-});
-module.exports = __toCommonJS(taskRunner_exports);
-var import_utils = require("patchright-core/lib/utils");
-var import_utils2 = require("patchright-core/lib/utils");
-var import_utilsBundle = require("patchright-core/lib/utilsBundle");
-var import_sigIntWatcher = require("./sigIntWatcher");
-var import_util = require("../util");
-class TaskRunner {
-  constructor(reporter, globalTimeoutForError) {
-    this._tasks = [];
-    this._hasErrors = false;
-    this._interrupted = false;
-    this._isTearDown = false;
-    this._reporter = reporter;
-    this._globalTimeoutForError = globalTimeoutForError;
-  }
-  addTask(task) {
-    this._tasks.push(task);
-  }
-  async run(context, deadline, cancelPromise) {
-    const { status, cleanup } = await this.runDeferCleanup(context, deadline, cancelPromise);
-    const teardownStatus = await cleanup();
-    return status === "passed" ? teardownStatus : status;
-  }
-  async runDeferCleanup(context, deadline, cancelPromise = new import_utils.ManualPromise()) {
-    const sigintWatcher = new import_sigIntWatcher.SigIntWatcher();
-    const timeoutWatcher = new TimeoutWatcher(deadline);
-    const teardownRunner = new TaskRunner(this._reporter, this._globalTimeoutForError);
-    teardownRunner._isTearDown = true;
-    let currentTaskName;
-    const taskLoop = async () => {
-      for (const task of this._tasks) {
-        currentTaskName = task.title;
-        if (this._interrupted)
-          break;
-        (0, import_utilsBundle.debug)("pw:test:task")(`"${task.title}" started`);
-        const errors = [];
-        const softErrors = [];
-        try {
-          teardownRunner._tasks.unshift({ title: `teardown for ${task.title}`, setup: task.teardown });
-          await task.setup?.(context, errors, softErrors);
-        } catch (e) {
-          (0, import_utilsBundle.debug)("pw:test:task")(`error in "${task.title}": `, e);
-          errors.push((0, import_util.serializeError)(e));
-        } finally {
-          for (const error of [...softErrors, ...errors])
-            this._reporter.onError?.(error);
-          if (errors.length) {
-            if (!this._isTearDown)
-              this._interrupted = true;
-            this._hasErrors = true;
-          }
-        }
-        (0, import_utilsBundle.debug)("pw:test:task")(`"${task.title}" finished`);
-      }
-    };
-    await Promise.race([
-      taskLoop(),
-      cancelPromise,
-      sigintWatcher.promise(),
-      timeoutWatcher.promise
-    ]);
-    sigintWatcher.disarm();
-    timeoutWatcher.disarm();
-    this._interrupted = true;
-    let status = "passed";
-    if (sigintWatcher.hadSignal() || cancelPromise?.isDone()) {
-      status = "interrupted";
-    } else if (timeoutWatcher.timedOut()) {
-      this._reporter.onError?.({ message: import_utils2.colors.red(`Timed out waiting ${this._globalTimeoutForError / 1e3}s for the ${currentTaskName} to run`) });
-      status = "timedout";
-    } else if (this._hasErrors) {
-      status = "failed";
-    }
-    cancelPromise?.resolve();
-    const cleanup = () => teardownRunner.runDeferCleanup(context, deadline).then((r) => r.status);
-    return { status, cleanup };
-  }
-}
-class TimeoutWatcher {
-  constructor(deadline) {
-    this._timedOut = false;
-    this.promise = new import_utils.ManualPromise();
-    if (!deadline)
-      return;
-    if (deadline - (0, import_utils.monotonicTime)() <= 0) {
-      this._timedOut = true;
-      this.promise.resolve();
-      return;
-    }
-    this._timer = setTimeout(() => {
-      this._timedOut = true;
-      this.promise.resolve();
-    }, deadline - (0, import_utils.monotonicTime)());
-  }
-  timedOut() {
-    return this._timedOut;
-  }
-  disarm() {
-    clearTimeout(this._timer);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TaskRunner
-});
+"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 taskRunner_exports = {};
+__export(taskRunner_exports, {
+  TaskRunner: () => TaskRunner
+});
+module.exports = __toCommonJS(taskRunner_exports);
+var import_utils = require("patchright-bun-core/lib/utils");
+var import_utils2 = require("patchright-bun-core/lib/utils");
+var import_utilsBundle = require("patchright-bun-core/lib/utilsBundle");
+var import_sigIntWatcher = require("./sigIntWatcher");
+var import_util = require("../util");
+class TaskRunner {
+  constructor(reporter, globalTimeoutForError) {
+    this._tasks = [];
+    this._hasErrors = false;
+    this._interrupted = false;
+    this._isTearDown = false;
+    this._reporter = reporter;
+    this._globalTimeoutForError = globalTimeoutForError;
+  }
+  addTask(task) {
+    this._tasks.push(task);
+  }
+  async run(context, deadline, cancelPromise) {
+    const { status, cleanup } = await this.runDeferCleanup(context, deadline, cancelPromise);
+    const teardownStatus = await cleanup();
+    return status === "passed" ? teardownStatus : status;
+  }
+  async runDeferCleanup(context, deadline, cancelPromise = new import_utils.ManualPromise()) {
+    const sigintWatcher = new import_sigIntWatcher.SigIntWatcher();
+    const timeoutWatcher = new TimeoutWatcher(deadline);
+    const teardownRunner = new TaskRunner(this._reporter, this._globalTimeoutForError);
+    teardownRunner._isTearDown = true;
+    let currentTaskName;
+    const taskLoop = async () => {
+      for (const task of this._tasks) {
+        currentTaskName = task.title;
+        if (this._interrupted)
+          break;
+        (0, import_utilsBundle.debug)("pw:test:task")(`"${task.title}" started`);
+        const errors = [];
+        const softErrors = [];
+        try {
+          teardownRunner._tasks.unshift({ title: `teardown for ${task.title}`, setup: task.teardown });
+          await task.setup?.(context, errors, softErrors);
+        } catch (e) {
+          (0, import_utilsBundle.debug)("pw:test:task")(`error in "${task.title}": `, e);
+          errors.push((0, import_util.serializeError)(e));
+        } finally {
+          for (const error of [...softErrors, ...errors])
+            this._reporter.onError?.(error);
+          if (errors.length) {
+            if (!this._isTearDown)
+              this._interrupted = true;
+            this._hasErrors = true;
+          }
+        }
+        (0, import_utilsBundle.debug)("pw:test:task")(`"${task.title}" finished`);
+      }
+    };
+    await Promise.race([
+      taskLoop(),
+      cancelPromise,
+      sigintWatcher.promise(),
+      timeoutWatcher.promise
+    ]);
+    sigintWatcher.disarm();
+    timeoutWatcher.disarm();
+    this._interrupted = true;
+    let status = "passed";
+    if (sigintWatcher.hadSignal() || cancelPromise?.isDone()) {
+      status = "interrupted";
+    } else if (timeoutWatcher.timedOut()) {
+      this._reporter.onError?.({ message: import_utils2.colors.red(`Timed out waiting ${this._globalTimeoutForError / 1e3}s for the ${currentTaskName} to run`) });
+      status = "timedout";
+    } else if (this._hasErrors) {
+      status = "failed";
+    }
+    cancelPromise?.resolve();
+    const cleanup = () => teardownRunner.runDeferCleanup(context, deadline).then((r) => r.status);
+    return { status, cleanup };
+  }
+}
+class TimeoutWatcher {
+  constructor(deadline) {
+    this._timedOut = false;
+    this.promise = new import_utils.ManualPromise();
+    if (!deadline)
+      return;
+    if (deadline - (0, import_utils.monotonicTime)() <= 0) {
+      this._timedOut = true;
+      this.promise.resolve();
+      return;
+    }
+    this._timer = setTimeout(() => {
+      this._timedOut = true;
+      this.promise.resolve();
+    }, deadline - (0, import_utils.monotonicTime)());
+  }
+  timedOut() {
+    return this._timedOut;
+  }
+  disarm() {
+    clearTimeout(this._timer);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TaskRunner
+});