@phpsandbox/sdk 0.0.44 → 0.0.46

package/dist/browser/phpsandbox-sdk.esm.js

@@ -1,311 +1,12 @@
-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 __typeError = (msg) => {
   throw TypeError(msg);
 };
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-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 __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
-// node_modules/retry/lib/retry_operation.js
-var require_retry_operation = __commonJS({
-  "node_modules/retry/lib/retry_operation.js"(exports, module) {
-    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);
-      }
-    }
-    module.exports = 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 timeout2 = this._timeouts.shift();
-      if (timeout2 === void 0) {
-        if (this._cachedTimeouts) {
-          this._errors.splice(0, this._errors.length - 1);
-          timeout2 = this._cachedTimeouts.slice(-1);
-        } else {
-          return false;
-        }
-      }
-      var self2 = this;
-      this._timer = setTimeout(function() {
-        self2._attempts++;
-        if (self2._operationTimeoutCb) {
-          self2._timeout = setTimeout(function() {
-            self2._operationTimeoutCb(self2._attempts);
-          }, self2._operationTimeout);
-          if (self2._options.unref) {
-            self2._timeout.unref();
-          }
-        }
-        self2._fn(self2._attempts);
-      }, timeout2);
-      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 self2 = this;
-      if (this._operationTimeoutCb) {
-        this._timeout = setTimeout(function() {
-          self2._operationTimeoutCb();
-        }, self2._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;
-    };
-  }
-});
-
-// node_modules/retry/lib/retry.js
-var require_retry = __commonJS({
-  "node_modules/retry/lib/retry.js"(exports) {
-    var RetryOperation = require_retry_operation();
-    exports.operation = function(options) {
-      var timeouts = exports.timeouts(options);
-      return new RetryOperation(timeouts, {
-        forever: options && (options.forever || options.retries === Infinity),
-        unref: options && options.unref,
-        maxRetryTime: options && options.maxRetryTime
-      });
-    };
-    exports.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.createTimeout = function(attempt, opts) {
-      var random = opts.randomize ? Math.random() + 1 : 1;
-      var timeout2 = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
-      timeout2 = Math.min(timeout2, opts.maxTimeout);
-      return timeout2;
-    };
-    exports.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.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;
-      }
-    };
-  }
-});
-
-// node_modules/retry/index.js
-var require_retry2 = __commonJS({
-  "node_modules/retry/index.js"(exports, module) {
-    module.exports = require_retry();
-  }
-});
-
-// node_modules/async-retry/lib/index.js
-var require_lib = __commonJS({
-  "node_modules/async-retry/lib/index.js"(exports, module) {
-    var retrier = require_retry2();
-    function retry3(fn, opts) {
-      function run(resolve, reject) {
-        var options = opts || {};
-        var op;
-        if (!("randomize" in options)) {
-          options.randomize = true;
-        }
-        op = retrier.operation(options);
-        function bail(err) {
-          reject(err || new Error("Aborted"));
-        }
-        function onError(err, num) {
-          if (err.bail) {
-            bail(err);
-            return;
-          }
-          if (!op.retry(err)) {
-            reject(op.mainError());
-          } else if (options.onRetry) {
-            options.onRetry(err, num);
-          }
-        }
-        function runAttempt(num) {
-          var val;
-          try {
-            val = fn(bail, num);
-          } catch (err) {
-            onError(err, num);
-            return;
-          }
-          Promise.resolve(val).then(resolve).catch(function catchIt(err) {
-            onError(err, num);
-          });
-        }
-        op.attempt(runAttempt);
-      }
-      return new Promise(run);
-    }
-    module.exports = retry3;
-  }
-});
-
 // src/types.ts
 var ErrorEvent = class extends Error {
   constructor(code, message, raw = {}) {
@@ -2626,8 +2327,51 @@ function decode(buffer, options) {
   return decoder.decode(buffer);
 }
 
-// src/socket/index.ts
-var import_async_retry = __toESM(require_lib(), 1);
+// src/utils/retry.ts
+var RetryBailError = class {
+  constructor(error) {
+    this.error = error;
+  }
+};
+var sleep = (duration) => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, duration);
+  });
+};
+var getRetryDelay = (attempt, options) => {
+  const randomized = options.randomize ? Math.random() + 1 : 1;
+  const exponentialDelay = Math.max(options.minTimeout, 1) * Math.pow(options.factor, attempt - 1);
+  return Math.round(Math.min(randomized * exponentialDelay, options.maxTimeout));
+};
+async function retry(fn, options = {}) {
+  const resolvedOptions = {
+    retries: options.retries ?? 10,
+    minTimeout: options.minTimeout ?? 1e3,
+    maxTimeout: options.maxTimeout ?? Infinity,
+    factor: options.factor ?? 2,
+    randomize: options.randomize ?? true
+  };
+  const bail = (error) => {
+    throw new RetryBailError(error ?? new Error("Aborted"));
+  };
+  let lastError;
+  for (let attempt = 1; attempt <= resolvedOptions.retries + 1; attempt++) {
+    try {
+      return await fn(bail, attempt);
+    } catch (error) {
+      if (error instanceof RetryBailError) {
+        throw error.error;
+      }
+      lastError = error;
+      if (attempt > resolvedOptions.retries) {
+        throw error;
+      }
+      await options.onRetry?.(error, attempt);
+      await sleep(getRetryDelay(attempt, resolvedOptions));
+    }
+  }
+  throw lastError;
+}
 
 // node_modules/reconnecting-websocket/dist/reconnecting-websocket-mjs.js
 var extendStatics = function(d, b) {
@@ -3744,7 +3488,7 @@ var Transport = class {
     return new Blob([encode(data)]);
   }
   sendWithRetry(sender, retries = 10) {
-    return (0, import_async_retry.default)(
+    return retry(
       async (bail, attempt) => {
         try {
           return await sender();
@@ -4300,9 +4044,6 @@ var Git = class {
   }
 };
 
-// src/beacon/index.ts
-var import_async_retry2 = __toESM(require_lib(), 1);
-
 // src/beacon/navigator.ts
 var Navigator = class {
   constructor(onEvent, onceEvent, beacon) {
@@ -4710,7 +4451,7 @@ var Beacon = class {
    * Wait for beacon to be ready - simplified approach
    */
   waitForBeaconReady() {
-    return (0, import_async_retry2.default)(
+    return retry(
       async () => {
         return new Promise((resolve, reject) => {
           if (this.isBeaconReady && this.channelEstablished) {
@@ -4775,7 +4516,7 @@ var Beacon = class {
    */
   async sendAndWaitFor(sendType, responseType, payload = {}, timeoutMs) {
     await this.ready();
-    return (0, import_async_retry2.default)(
+    return retry(
       async (bail) => {
         return new Promise((resolve, reject) => {
           const actualTimeout = timeoutMs || this.options.timeout;
@@ -4938,7 +4679,8 @@ var Beacon = class {
    * Capture the current beacon document, optionally clipped to a viewport or document rectangle.
    */
   async captureScreenshot(request = {}) {
-    const timeoutMs = (request.timeout || 3e4) + 5e3;
+    const mediaTimeoutMs = request.mediaTimeoutMs ?? request.timeout ?? 3e4;
+    const timeoutMs = request.transportTimeoutMs ?? mediaTimeoutMs + 5e3;
     return this.sendAndWaitFor("captureScreenshot", "screenshotResult", request, timeoutMs);
   }
   /**