@phpsandbox/sdk 0.0.45 → 0.0.47

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

@@ -1,16 +1,11 @@
 var PHPSandbox = (() => {
-  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 __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -23,14 +18,6 @@ var PHPSandbox = (() => {
     }
     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 __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));
@@ -38,280 +25,6 @@ var PHPSandbox = (() => {
   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/index.ts
   var index_exports = {};
   __export(index_exports, {
@@ -2675,8 +2388,51 @@ var PHPSandbox = (() => {
     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) {
@@ -3793,7 +3549,7 @@ var PHPSandbox = (() => {
       return new Blob([encode(data)]);
     }
     sendWithRetry(sender, retries = 10) {
-      return (0, import_async_retry.default)(
+      return retry(
         async (bail, attempt) => {
           try {
             return await sender();
@@ -4349,9 +4105,6 @@ var PHPSandbox = (() => {
     }
   };
 
-  // src/beacon/index.ts
-  var import_async_retry2 = __toESM(require_lib(), 1);
-
   // src/beacon/navigator.ts
   var Navigator = class {
     constructor(onEvent, onceEvent, beacon) {
@@ -4759,7 +4512,7 @@ var PHPSandbox = (() => {
      * 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) {
@@ -4824,7 +4577,7 @@ var PHPSandbox = (() => {
      */
     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;