@stablyai/playwright-test 2.0.15 → 2.0.16

package/dist/{index-BklBJUIC.mjs → index-Tn_eFdjz.mjs}

@@ -6386,204 +6386,331 @@ function requireWebsocketServer () {
 
 requireWebsocketServer();
 
-const objectToString = Object.prototype.toString;
-const isError = (value) => objectToString.call(value) === "[object Error]";
-const errorMessages = /* @__PURE__ */ new Set([
-  "network error",
-  // Chrome
-  "Failed to fetch",
-  // Chrome
-  "NetworkError when attempting to fetch resource.",
-  // Firefox
-  "The Internet connection appears to be offline.",
-  // Safari 16
-  "Network request failed",
-  // `cross-fetch`
-  "fetch failed",
-  // Undici (Node.js)
-  "terminated",
-  // Undici (Node.js)
-  " A network error occurred.",
-  // Bun (WebKit)
-  "Network connection lost"
-  // Cloudflare Workers (fetch)
-]);
-function isNetworkError(error) {
-  const isValid = error && isError(error) && error.name === "TypeError" && typeof error.message === "string";
-  if (!isValid) {
-    return false;
-  }
-  const { message, stack } = error;
-  if (message === "Load failed") {
-    return stack === void 0 || "__sentry_captured__" in error;
-  }
-  if (message.startsWith("error sending request for url")) {
-    return true;
-  }
-  return errorMessages.has(message);
-}
+var pRetry = {exports: {}};
 
-function validateRetries(retries) {
-  if (typeof retries === "number") {
-    if (retries < 0) {
-      throw new TypeError("Expected `retries` to be a non-negative number.");
-    }
-    if (Number.isNaN(retries)) {
-      throw new TypeError("Expected `retries` to be a valid number or Infinity, got NaN.");
-    }
-  } else if (retries !== void 0) {
-    throw new TypeError("Expected `retries` to be a number or Infinity.");
-  }
+var retry$1 = {};
+
+var retry_operation;
+var hasRequiredRetry_operation;
+
+function requireRetry_operation () {
+	if (hasRequiredRetry_operation) return retry_operation;
+	hasRequiredRetry_operation = 1;
+	function RetryOperation(timeouts, options) {
+	  if (typeof options === "boolean") {
+	    options = { forever: options };
+	  }
+	  this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+	  this._timeouts = timeouts;
+	  this._options = options || {};
+	  this._maxRetryTime = options && options.maxRetryTime || Infinity;
+	  this._fn = null;
+	  this._errors = [];
+	  this._attempts = 1;
+	  this._operationTimeout = null;
+	  this._operationTimeoutCb = null;
+	  this._timeout = null;
+	  this._operationStart = null;
+	  this._timer = null;
+	  if (this._options.forever) {
+	    this._cachedTimeouts = this._timeouts.slice(0);
+	  }
+	}
+	retry_operation = RetryOperation;
+	RetryOperation.prototype.reset = function() {
+	  this._attempts = 1;
+	  this._timeouts = this._originalTimeouts.slice(0);
+	};
+	RetryOperation.prototype.stop = function() {
+	  if (this._timeout) {
+	    clearTimeout(this._timeout);
+	  }
+	  if (this._timer) {
+	    clearTimeout(this._timer);
+	  }
+	  this._timeouts = [];
+	  this._cachedTimeouts = null;
+	};
+	RetryOperation.prototype.retry = function(err) {
+	  if (this._timeout) {
+	    clearTimeout(this._timeout);
+	  }
+	  if (!err) {
+	    return false;
+	  }
+	  var currentTime = (/* @__PURE__ */ new Date()).getTime();
+	  if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+	    this._errors.push(err);
+	    this._errors.unshift(new Error("RetryOperation timeout occurred"));
+	    return false;
+	  }
+	  this._errors.push(err);
+	  var timeout = this._timeouts.shift();
+	  if (timeout === void 0) {
+	    if (this._cachedTimeouts) {
+	      this._errors.splice(0, this._errors.length - 1);
+	      timeout = this._cachedTimeouts.slice(-1);
+	    } else {
+	      return false;
+	    }
+	  }
+	  var self = this;
+	  this._timer = setTimeout(function() {
+	    self._attempts++;
+	    if (self._operationTimeoutCb) {
+	      self._timeout = setTimeout(function() {
+	        self._operationTimeoutCb(self._attempts);
+	      }, self._operationTimeout);
+	      if (self._options.unref) {
+	        self._timeout.unref();
+	      }
+	    }
+	    self._fn(self._attempts);
+	  }, timeout);
+	  if (this._options.unref) {
+	    this._timer.unref();
+	  }
+	  return true;
+	};
+	RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+	  this._fn = fn;
+	  if (timeoutOps) {
+	    if (timeoutOps.timeout) {
+	      this._operationTimeout = timeoutOps.timeout;
+	    }
+	    if (timeoutOps.cb) {
+	      this._operationTimeoutCb = timeoutOps.cb;
+	    }
+	  }
+	  var self = this;
+	  if (this._operationTimeoutCb) {
+	    this._timeout = setTimeout(function() {
+	      self._operationTimeoutCb();
+	    }, self._operationTimeout);
+	  }
+	  this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+	  this._fn(this._attempts);
+	};
+	RetryOperation.prototype.try = function(fn) {
+	  console.log("Using RetryOperation.try() is deprecated");
+	  this.attempt(fn);
+	};
+	RetryOperation.prototype.start = function(fn) {
+	  console.log("Using RetryOperation.start() is deprecated");
+	  this.attempt(fn);
+	};
+	RetryOperation.prototype.start = RetryOperation.prototype.try;
+	RetryOperation.prototype.errors = function() {
+	  return this._errors;
+	};
+	RetryOperation.prototype.attempts = function() {
+	  return this._attempts;
+	};
+	RetryOperation.prototype.mainError = function() {
+	  if (this._errors.length === 0) {
+	    return null;
+	  }
+	  var counts = {};
+	  var mainError = null;
+	  var mainErrorCount = 0;
+	  for (var i = 0; i < this._errors.length; i++) {
+	    var error = this._errors[i];
+	    var message = error.message;
+	    var count = (counts[message] || 0) + 1;
+	    counts[message] = count;
+	    if (count >= mainErrorCount) {
+	      mainError = error;
+	      mainErrorCount = count;
+	    }
+	  }
+	  return mainError;
+	};
+	return retry_operation;
 }
-function validateNumberOption(name, value, { min = 0, allowInfinity = false } = {}) {
-  if (value === void 0) {
-    return;
-  }
-  if (typeof value !== "number" || Number.isNaN(value)) {
-    throw new TypeError(`Expected \`${name}\` to be a number${allowInfinity ? " or Infinity" : ""}.`);
-  }
-  if (!allowInfinity && !Number.isFinite(value)) {
-    throw new TypeError(`Expected \`${name}\` to be a finite number.`);
-  }
-  if (value < min) {
-    throw new TypeError(`Expected \`${name}\` to be \u2265 ${min}.`);
-  }
+
+var hasRequiredRetry$1;
+
+function requireRetry$1 () {
+	if (hasRequiredRetry$1) return retry$1;
+	hasRequiredRetry$1 = 1;
+	(function (exports$1) {
+		var RetryOperation = requireRetry_operation();
+		exports$1.operation = function(options) {
+		  var timeouts = exports$1.timeouts(options);
+		  return new RetryOperation(timeouts, {
+		    forever: options && (options.forever || options.retries === Infinity),
+		    unref: options && options.unref,
+		    maxRetryTime: options && options.maxRetryTime
+		  });
+		};
+		exports$1.timeouts = function(options) {
+		  if (options instanceof Array) {
+		    return [].concat(options);
+		  }
+		  var opts = {
+		    retries: 10,
+		    factor: 2,
+		    minTimeout: 1 * 1e3,
+		    maxTimeout: Infinity,
+		    randomize: false
+		  };
+		  for (var key in options) {
+		    opts[key] = options[key];
+		  }
+		  if (opts.minTimeout > opts.maxTimeout) {
+		    throw new Error("minTimeout is greater than maxTimeout");
+		  }
+		  var timeouts = [];
+		  for (var i = 0; i < opts.retries; i++) {
+		    timeouts.push(this.createTimeout(i, opts));
+		  }
+		  if (options && options.forever && !timeouts.length) {
+		    timeouts.push(this.createTimeout(i, opts));
+		  }
+		  timeouts.sort(function(a, b) {
+		    return a - b;
+		  });
+		  return timeouts;
+		};
+		exports$1.createTimeout = function(attempt, opts) {
+		  var random = opts.randomize ? Math.random() + 1 : 1;
+		  var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+		  timeout = Math.min(timeout, opts.maxTimeout);
+		  return timeout;
+		};
+		exports$1.wrap = function(obj, options, methods) {
+		  if (options instanceof Array) {
+		    methods = options;
+		    options = null;
+		  }
+		  if (!methods) {
+		    methods = [];
+		    for (var key in obj) {
+		      if (typeof obj[key] === "function") {
+		        methods.push(key);
+		      }
+		    }
+		  }
+		  for (var i = 0; i < methods.length; i++) {
+		    var method = methods[i];
+		    var original = obj[method];
+		    obj[method] = function retryWrapper(original2) {
+		      var op = exports$1.operation(options);
+		      var args = Array.prototype.slice.call(arguments, 1);
+		      var callback = args.pop();
+		      args.push(function(err) {
+		        if (op.retry(err)) {
+		          return;
+		        }
+		        if (err) {
+		          arguments[0] = op.mainError();
+		        }
+		        callback.apply(this, arguments);
+		      });
+		      op.attempt(function() {
+		        original2.apply(obj, args);
+		      });
+		    }.bind(obj, original);
+		    obj[method].options = options;
+		  }
+		}; 
+	} (retry$1));
+	return retry$1;
 }
-class AbortError extends Error {
-  constructor(message) {
-    super();
-    if (message instanceof Error) {
-      this.originalError = message;
-      ({ message } = message);
-    } else {
-      this.originalError = new Error(message);
-      this.originalError.stack = this.stack;
-    }
-    this.name = "AbortError";
-    this.message = message;
-  }
-}
-function calculateDelay(retriesConsumed, options) {
-  const attempt = Math.max(1, retriesConsumed + 1);
-  const random = options.randomize ? Math.random() + 1 : 1;
-  let timeout = Math.round(random * options.minTimeout * options.factor ** (attempt - 1));
-  timeout = Math.min(timeout, options.maxTimeout);
-  return timeout;
-}
-function calculateRemainingTime(start, max) {
-  if (!Number.isFinite(max)) {
-    return max;
-  }
-  return max - (performance.now() - start);
-}
-async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTime, options }) {
-  const normalizedError = error instanceof Error ? error : new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
-  if (normalizedError instanceof AbortError) {
-    throw normalizedError.originalError;
-  }
-  const retriesLeft = Number.isFinite(options.retries) ? Math.max(0, options.retries - retriesConsumed) : options.retries;
-  const maxRetryTime = options.maxRetryTime ?? Number.POSITIVE_INFINITY;
-  const context = Object.freeze({
-    error: normalizedError,
-    attemptNumber,
-    retriesLeft,
-    retriesConsumed
-  });
-  await options.onFailedAttempt(context);
-  if (calculateRemainingTime(startTime, maxRetryTime) <= 0) {
-    throw normalizedError;
-  }
-  const consumeRetry = await options.shouldConsumeRetry(context);
-  const remainingTime = calculateRemainingTime(startTime, maxRetryTime);
-  if (remainingTime <= 0 || retriesLeft <= 0) {
-    throw normalizedError;
-  }
-  if (normalizedError instanceof TypeError && !isNetworkError(normalizedError)) {
-    if (consumeRetry) {
-      throw normalizedError;
-    }
-    options.signal?.throwIfAborted();
-    return false;
-  }
-  if (!await options.shouldRetry(context)) {
-    throw normalizedError;
-  }
-  if (!consumeRetry) {
-    options.signal?.throwIfAborted();
-    return false;
-  }
-  const delayTime = calculateDelay(retriesConsumed, options);
-  const finalDelay = Math.min(delayTime, remainingTime);
-  options.signal?.throwIfAborted();
-  if (finalDelay > 0) {
-    await new Promise((resolve, reject) => {
-      const onAbort = () => {
-        clearTimeout(timeoutToken);
-        options.signal?.removeEventListener("abort", onAbort);
-        reject(options.signal.reason);
-      };
-      const timeoutToken = setTimeout(() => {
-        options.signal?.removeEventListener("abort", onAbort);
-        resolve();
-      }, finalDelay);
-      if (options.unref) {
-        timeoutToken.unref?.();
-      }
-      options.signal?.addEventListener("abort", onAbort, { once: true });
-    });
-  }
-  options.signal?.throwIfAborted();
-  return true;
+
+var retry;
+var hasRequiredRetry;
+
+function requireRetry () {
+	if (hasRequiredRetry) return retry;
+	hasRequiredRetry = 1;
+	retry = requireRetry$1();
+	return retry;
 }
-async function pRetry(input, options = {}) {
-  options = { ...options };
-  validateRetries(options.retries);
-  if (Object.hasOwn(options, "forever")) {
-    throw new Error("The `forever` option is no longer supported. For many use-cases, you can set `retries: Infinity` instead.");
-  }
-  options.retries ??= 10;
-  options.factor ??= 2;
-  options.minTimeout ??= 1e3;
-  options.maxTimeout ??= Number.POSITIVE_INFINITY;
-  options.maxRetryTime ??= Number.POSITIVE_INFINITY;
-  options.randomize ??= false;
-  options.onFailedAttempt ??= () => {
-  };
-  options.shouldRetry ??= () => true;
-  options.shouldConsumeRetry ??= () => true;
-  validateNumberOption("factor", options.factor, { min: 0, allowInfinity: false });
-  validateNumberOption("minTimeout", options.minTimeout, { min: 0, allowInfinity: false });
-  validateNumberOption("maxTimeout", options.maxTimeout, { min: 0, allowInfinity: true });
-  validateNumberOption("maxRetryTime", options.maxRetryTime, { min: 0, allowInfinity: true });
-  if (!(options.factor > 0)) {
-    options.factor = 1;
-  }
-  options.signal?.throwIfAborted();
-  let attemptNumber = 0;
-  let retriesConsumed = 0;
-  const startTime = performance.now();
-  while (Number.isFinite(options.retries) ? retriesConsumed <= options.retries : true) {
-    attemptNumber++;
-    try {
-      options.signal?.throwIfAborted();
-      const result = await input(attemptNumber);
-      options.signal?.throwIfAborted();
-      return result;
-    } catch (error) {
-      if (await onAttemptFailure({
-        error,
-        attemptNumber,
-        retriesConsumed,
-        startTime,
-        options
-      })) {
-        retriesConsumed++;
-      }
-    }
-  }
-  throw new Error("Retry attempts exhausted without throwing an error.");
+
+var hasRequiredPRetry;
+
+function requirePRetry () {
+	if (hasRequiredPRetry) return pRetry.exports;
+	hasRequiredPRetry = 1;
+	const retry = requireRetry();
+	const networkErrorMsgs = [
+	  "Failed to fetch",
+	  // Chrome
+	  "NetworkError when attempting to fetch resource.",
+	  // Firefox
+	  "The Internet connection appears to be offline.",
+	  // Safari
+	  "Network request failed"
+	  // `cross-fetch`
+	];
+	class AbortError extends Error {
+	  constructor(message) {
+	    super();
+	    if (message instanceof Error) {
+	      this.originalError = message;
+	      ({ message } = message);
+	    } else {
+	      this.originalError = new Error(message);
+	      this.originalError.stack = this.stack;
+	    }
+	    this.name = "AbortError";
+	    this.message = message;
+	  }
+	}
+	const decorateErrorWithCounts = (error, attemptNumber, options) => {
+	  const retriesLeft = options.retries - (attemptNumber - 1);
+	  error.attemptNumber = attemptNumber;
+	  error.retriesLeft = retriesLeft;
+	  return error;
+	};
+	const isNetworkError = (errorMessage) => networkErrorMsgs.includes(errorMessage);
+	const pRetry$1 = (input, options) => new Promise((resolve, reject) => {
+	  options = {
+	    onFailedAttempt: () => {
+	    },
+	    retries: 10,
+	    ...options
+	  };
+	  const operation = retry.operation(options);
+	  operation.attempt(async (attemptNumber) => {
+	    try {
+	      resolve(await input(attemptNumber));
+	    } catch (error) {
+	      if (!(error instanceof Error)) {
+	        reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
+	        return;
+	      }
+	      if (error instanceof AbortError) {
+	        operation.stop();
+	        reject(error.originalError);
+	      } else if (error instanceof TypeError && !isNetworkError(error.message)) {
+	        operation.stop();
+	        reject(error);
+	      } else {
+	        decorateErrorWithCounts(error, attemptNumber, options);
+	        try {
+	          await options.onFailedAttempt(error);
+	        } catch (error2) {
+	          reject(error2);
+	          return;
+	        }
+	        if (!operation.retry(error)) {
+	          reject(operation.mainError());
+	        }
+	      }
+	    }
+	  });
+	});
+	pRetry.exports = pRetry$1;
+	pRetry.exports.default = pRetry$1;
+	pRetry.exports.AbortError = AbortError;
+	return pRetry.exports;
 }
 
+var pRetryExports = requirePRetry();
+var ai = /*@__PURE__*/getDefaultExportFromCjs(pRetryExports);
+
 var Yn = Object.defineProperty;
 var s = (e, t) => Yn(e, "name", { value: t, configurable: true });
 const st = BigInt(2 ** 32 - 1), Ar = BigInt(32);
@@ -9463,9 +9590,9 @@ function Wn({ sensitiveValues: e, step: t }) {
 }
 s(Wn, "extractStep");
 async function La({ fileData: e, maxRetries: t = 3, uploadUrl: r }) {
-  await pRetry(async () => {
+  await ai(async () => {
     const n = await fetch(r, { body: e, method: "PUT" });
-    if (!n.ok) throw n.status >= 400 && n.status < 500 ? new AbortError(`Upload failed with status ${n.status}: ${n.statusText}`) : new Error(`Upload failed with status ${n.status}: ${n.statusText}`);
+    if (!n.ok) throw n.status >= 400 && n.status < 500 ? new pRetryExports.AbortError(`Upload failed with status ${n.status}: ${n.statusText}`) : new Error(`Upload failed with status ${n.status}: ${n.statusText}`);
   }, { minTimeout: 2e3, randomize: true, retries: t });
 }
 s(La, "uploadWithRetry");
@@ -9652,4 +9779,4 @@ function xa(e) {
 s(xa, "stablyReporter");
 
 export { Vn as V, xa as x };
-//# sourceMappingURL=index-BklBJUIC.mjs.map
+//# sourceMappingURL=index-Tn_eFdjz.mjs.map