websocket-ts 2.1.1 → 2.1.3

package/dist/cjs/src/backoff/backoff.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A Backoff produces a series of numbers that are used to determine
+ * the delay between connection-retries. Values are expected to be in milliseconds.
+ */
+export interface Backoff {
+    /**
+     * The number of retries. Starts at 0, increases by 1 for each call to next(). Resets to 0 when reset() is called.
+     */
+    readonly retries: number;
+    /**
+     * Current number in the series.
+     */
+    readonly current: number;
+    /**
+     * Advances the series to the next number and returns it.
+     * @return the next number in the series
+     */
+    next(): number;
+    /**
+     * Resets the series to its initial state.
+     */
+    reset(): void;
+}
+//# sourceMappingURL=backoff.d.ts.map

package/dist/cjs/src/backoff/backoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoff.d.ts","sourceRoot":"","sources":["../../../../src/backoff/backoff.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,IAAI,IAAI,MAAM,CAAC;IAEf;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;CACf"}

package/dist/cjs/src/backoff/backoff.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=backoff.js.map

package/dist/cjs/src/backoff/backoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoff.js","sourceRoot":"","sources":["../../../../src/backoff/backoff.ts"],"names":[],"mappings":""}

package/dist/cjs/src/backoff/constantbackoff.d.ts

@@ -0,0 +1,18 @@
+import { Backoff } from "./backoff";
+/**
+ * ConstantBackoff always returns the same backoff-time.
+ */
+export declare class ConstantBackoff implements Backoff {
+    private readonly backoff;
+    private _retries;
+    /**
+     * Creates a new ConstantBackoff.
+     * @param backoff the backoff-time to return
+     */
+    constructor(backoff: number);
+    get retries(): number;
+    get current(): number;
+    next(): number;
+    reset(): void;
+}
+//# sourceMappingURL=constantbackoff.d.ts.map

package/dist/cjs/src/backoff/constantbackoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constantbackoff.d.ts","sourceRoot":"","sources":["../../../../src/backoff/constantbackoff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;GAEG;AACH,qBAAa,eAAgB,YAAW,OAAO;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAa;IAE7B;;;OAGG;gBACS,OAAO,EAAE,MAAM;IAQ3B,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,IAAI,MAAM;IAKd,KAAK,IAAI,IAAI;CAGd"}

package/dist/cjs/src/backoff/constantbackoff.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstantBackoff = void 0;
+/**
+ * ConstantBackoff always returns the same backoff-time.
+ */
+var ConstantBackoff = /** @class */ (function () {
+    /**
+     * Creates a new ConstantBackoff.
+     * @param backoff the backoff-time to return
+     */
+    function ConstantBackoff(backoff) {
+        this._retries = 0;
+        if (!Number.isInteger(backoff) || backoff < 0) {
+            throw new Error("Backoff must be a positive integer");
+        }
+        this.backoff = backoff;
+    }
+    Object.defineProperty(ConstantBackoff.prototype, "retries", {
+        get: function () {
+            return this._retries;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ConstantBackoff.prototype, "current", {
+        get: function () {
+            return this.backoff;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConstantBackoff.prototype.next = function () {
+        this._retries++;
+        return this.backoff;
+    };
+    ConstantBackoff.prototype.reset = function () {
+        this._retries = 0;
+    };
+    return ConstantBackoff;
+}());
+exports.ConstantBackoff = ConstantBackoff;
+//# sourceMappingURL=constantbackoff.js.map

package/dist/cjs/src/backoff/constantbackoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constantbackoff.js","sourceRoot":"","sources":["../../../../src/backoff/constantbackoff.ts"],"names":[],"mappings":";;;AAEA;;GAEG;AACH;IAIE;;;OAGG;IACH,yBAAY,OAAe;QANnB,aAAQ,GAAW,CAAC,CAAC;QAO3B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,OAAO,GAAG,CAAC,EAAE;YAC7C,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;SACvD;QAED,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED,sBAAI,oCAAO;aAAX;YACE,OAAO,IAAI,CAAC,QAAQ,CAAC;QACvB,CAAC;;;OAAA;IAED,sBAAI,oCAAO;aAAX;YACE,OAAO,IAAI,CAAC,OAAO,CAAC;QACtB,CAAC;;;OAAA;IAED,8BAAI,GAAJ;QACE,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,+BAAK,GAAL;QACE,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;IACpB,CAAC;IACH,sBAAC;AAAD,CAAC,AAhCD,IAgCC;AAhCY,0CAAe"}

package/dist/cjs/src/backoff/exponentialbackoff.d.ts

@@ -0,0 +1,48 @@
+import { Backoff } from "./backoff";
+/**
+ * ExponentialBackoff increases the backoff-time exponentially.
+ * An optional maximum can be provided as an upper bound to the
+ * exponent and thus to the returned backoff.
+ *
+ * The series can be described as ('i' is the current step/retry):
+ *    backoff = base * 2^i                | without bound
+ *    backoff = base * 2^min(i, expMax)   | with bound
+ *
+ * Example:
+ *
+ * 1) Without bound:
+ *   base = 1000, expMax = undefined
+ *   backoff = 1000 * 2^0 = 1000 // first retry
+ *   backoff = 1000 * 2^1 = 2000 // second retry
+ *   backoff = 1000 * 2^2 = 4000 // ...doubles with every retry
+ *   backoff = 1000 * 2^3 = 8000
+ *   backoff = 1000 * 2^4 = 16000
+ *   ... // and so on
+ *
+ * 2) With bound:
+ *  base = 1000, expMax = 3
+ *  backoff = 1000 * 2^0 = 1000 // first retry
+ *  backoff = 1000 * 2^1 = 2000 // second retry
+ *  backoff = 1000 * 2^2 = 4000 // third retry
+ *  backoff = 1000 * 2^3 = 8000 // maximum reached, don't increase further
+ *  backoff = 1000 * 2^3 = 8000
+ *  backoff = 1000 * 2^3 = 8000
+ *  ... // and so on
+ */
+export declare class ExponentialBackoff implements Backoff {
+    private readonly base;
+    private readonly expMax?;
+    private i;
+    private _retries;
+    /**
+     * Creates a new ExponentialBackoff.
+     * @param base the base of the exponentiation
+     * @param expMax the maximum exponent, no bound if undefined
+     */
+    constructor(base: number, expMax?: number);
+    get retries(): number;
+    get current(): number;
+    next(): number;
+    reset(): void;
+}
+//# sourceMappingURL=exponentialbackoff.d.ts.map

package/dist/cjs/src/backoff/exponentialbackoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exponentialbackoff.d.ts","sourceRoot":"","sources":["../../../../src/backoff/exponentialbackoff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,kBAAmB,YAAW,OAAO;IAChD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAS;IACjC,OAAO,CAAC,CAAC,CAAS;IAClB,OAAO,CAAC,QAAQ,CAAa;IAE7B;;;;OAIG;gBACS,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAazC,IAAI,OAAO,WAEV;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,IAAI,MAAM;IASd,KAAK,IAAI,IAAI;CAId"}

package/dist/cjs/src/backoff/exponentialbackoff.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExponentialBackoff = void 0;
+/**
+ * ExponentialBackoff increases the backoff-time exponentially.
+ * An optional maximum can be provided as an upper bound to the
+ * exponent and thus to the returned backoff.
+ *
+ * The series can be described as ('i' is the current step/retry):
+ *    backoff = base * 2^i                | without bound
+ *    backoff = base * 2^min(i, expMax)   | with bound
+ *
+ * Example:
+ *
+ * 1) Without bound:
+ *   base = 1000, expMax = undefined
+ *   backoff = 1000 * 2^0 = 1000 // first retry
+ *   backoff = 1000 * 2^1 = 2000 // second retry
+ *   backoff = 1000 * 2^2 = 4000 // ...doubles with every retry
+ *   backoff = 1000 * 2^3 = 8000
+ *   backoff = 1000 * 2^4 = 16000
+ *   ... // and so on
+ *
+ * 2) With bound:
+ *  base = 1000, expMax = 3
+ *  backoff = 1000 * 2^0 = 1000 // first retry
+ *  backoff = 1000 * 2^1 = 2000 // second retry
+ *  backoff = 1000 * 2^2 = 4000 // third retry
+ *  backoff = 1000 * 2^3 = 8000 // maximum reached, don't increase further
+ *  backoff = 1000 * 2^3 = 8000
+ *  backoff = 1000 * 2^3 = 8000
+ *  ... // and so on
+ */
+var ExponentialBackoff = /** @class */ (function () {
+    /**
+     * Creates a new ExponentialBackoff.
+     * @param base the base of the exponentiation
+     * @param expMax the maximum exponent, no bound if undefined
+     */
+    function ExponentialBackoff(base, expMax) {
+        this._retries = 0;
+        if (!Number.isInteger(base) || base < 0) {
+            throw new Error("Base must be a positive integer or zero");
+        }
+        if (expMax !== undefined && (!Number.isInteger(expMax) || expMax < 0)) {
+            throw new Error("ExpMax must be a undefined, a positive integer or zero");
+        }
+        this.base = base;
+        this.expMax = expMax;
+        this.i = 0;
+    }
+    Object.defineProperty(ExponentialBackoff.prototype, "retries", {
+        get: function () {
+            return this._retries;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ExponentialBackoff.prototype, "current", {
+        get: function () {
+            return this.base * Math.pow(2, this.i);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ExponentialBackoff.prototype.next = function () {
+        this._retries++;
+        this.i =
+            this.expMax === undefined
+                ? this.i + 1
+                : Math.min(this.i + 1, this.expMax);
+        return this.current;
+    };
+    ExponentialBackoff.prototype.reset = function () {
+        this._retries = 0;
+        this.i = 0;
+    };
+    return ExponentialBackoff;
+}());
+exports.ExponentialBackoff = ExponentialBackoff;
+//# sourceMappingURL=exponentialbackoff.js.map

package/dist/cjs/src/backoff/exponentialbackoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exponentialbackoff.js","sourceRoot":"","sources":["../../../../src/backoff/exponentialbackoff.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAME;;;;OAIG;IACH,4BAAY,IAAY,EAAE,MAAe;QAPjC,aAAQ,GAAW,CAAC,CAAC;QAQ3B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,EAAE;YACvC,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;SAC5D;QACD,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,CAAC,EAAE;YACrE,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;SAC3E;QAED,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;IACb,CAAC;IAED,sBAAI,uCAAO;aAAX;YACE,OAAO,IAAI,CAAC,QAAQ,CAAC;QACvB,CAAC;;;OAAA;IAED,sBAAI,uCAAO;aAAX;YACE,OAAO,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC;;;OAAA;IAED,iCAAI,GAAJ;QACE,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChB,IAAI,CAAC,CAAC;YACJ,IAAI,CAAC,MAAM,KAAK,SAAS;gBACvB,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC;gBACZ,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACxC,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,kCAAK,GAAL;QACE,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QAClB,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;IACb,CAAC;IACH,yBAAC;AAAD,CAAC,AA7CD,IA6CC;AA7CY,gDAAkB"}

package/dist/cjs/src/backoff/linearbackoff.d.ts

@@ -0,0 +1,51 @@
+import { Backoff } from "./backoff";
+/**
+ * LinearBackoff returns a backoff-time that is incremented by a fixed amount
+ * with every step/retry. An optional maximum can be provided as an upper bound
+ * to the returned backoff.
+ *
+ * The series can be described as ('i' is the current step/retry):
+ *   backoff = initial + increment * i                | without bound
+ *   backoff = initial + increment * min(i, max)      | with bound
+ *
+ * Example:
+ *
+ * 1) Without bound:
+ *  initial = 1000, increment = 1000
+ *  backoff = 1000 + 1000 * 0 = 1000 // first retry
+ *  backoff = 1000 + 1000 * 1 = 2000 // second retry
+ *  backoff = 1000 + 1000 * 2 = 3000 // ...increases by 'increment' with every retry
+ *  backoff = 1000 + 1000 * 3 = 4000
+ *  backoff = 1000 + 1000 * 4 = 5000
+ *  ... // and so on
+ *
+ *  2) With bound:
+ *  initial = 1000, increment = 1000, max = 5000
+ *  backoff = 1000 + 1000 * 0 = 1000 // first retry
+ *  backoff = 1000 + 1000 * 1 = 2000 // second retry
+ *  backoff = 1000 + 1000 * 2 = 3000 // third retry
+ *  backoff = 1000 + 1000 * 3 = 4000 // fourth retry
+ *  backoff = 1000 + 1000 * 4 = 5000 // maximum reached, don't increase further
+ *  backoff = 1000 + 1000 * 4 = 5000
+ *  backoff = 1000 + 1000 * 4 = 5000
+ *  ... // and so on
+ */
+export declare class LinearBackoff implements Backoff {
+    private readonly initial;
+    private readonly increment;
+    private readonly max?;
+    private i;
+    private _retries;
+    /**
+     * Creates a new LinearBackoff.
+     * @param initial the initial backoff-time in milliseconds
+     * @param increment the amount to increment the backoff-time with every step (in milliseconds)
+     * @param max the maximum backoff-time (in milliseconds), no bound if undefined
+     */
+    constructor(initial: number, increment: number, max?: number);
+    get retries(): number;
+    get current(): number;
+    next(): number;
+    reset(): void;
+}
+//# sourceMappingURL=linearbackoff.d.ts.map

package/dist/cjs/src/backoff/linearbackoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linearbackoff.d.ts","sourceRoot":"","sources":["../../../../src/backoff/linearbackoff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,aAAc,YAAW,OAAO;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAS;IAC9B,OAAO,CAAC,CAAC,CAAa;IACtB,OAAO,CAAC,QAAQ,CAAa;IAE7B;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAqB5D,IAAI,OAAO,WAEV;IAED,IAAI,OAAO,IAAI,MAAM,CAIpB;IAED,IAAI,IAAI,MAAM;IAMd,KAAK,IAAI,IAAI;CAId"}

package/dist/cjs/src/backoff/linearbackoff.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinearBackoff = void 0;
+/**
+ * LinearBackoff returns a backoff-time that is incremented by a fixed amount
+ * with every step/retry. An optional maximum can be provided as an upper bound
+ * to the returned backoff.
+ *
+ * The series can be described as ('i' is the current step/retry):
+ *   backoff = initial + increment * i                | without bound
+ *   backoff = initial + increment * min(i, max)      | with bound
+ *
+ * Example:
+ *
+ * 1) Without bound:
+ *  initial = 1000, increment = 1000
+ *  backoff = 1000 + 1000 * 0 = 1000 // first retry
+ *  backoff = 1000 + 1000 * 1 = 2000 // second retry
+ *  backoff = 1000 + 1000 * 2 = 3000 // ...increases by 'increment' with every retry
+ *  backoff = 1000 + 1000 * 3 = 4000
+ *  backoff = 1000 + 1000 * 4 = 5000
+ *  ... // and so on
+ *
+ *  2) With bound:
+ *  initial = 1000, increment = 1000, max = 5000
+ *  backoff = 1000 + 1000 * 0 = 1000 // first retry
+ *  backoff = 1000 + 1000 * 1 = 2000 // second retry
+ *  backoff = 1000 + 1000 * 2 = 3000 // third retry
+ *  backoff = 1000 + 1000 * 3 = 4000 // fourth retry
+ *  backoff = 1000 + 1000 * 4 = 5000 // maximum reached, don't increase further
+ *  backoff = 1000 + 1000 * 4 = 5000
+ *  backoff = 1000 + 1000 * 4 = 5000
+ *  ... // and so on
+ */
+var LinearBackoff = /** @class */ (function () {
+    /**
+     * Creates a new LinearBackoff.
+     * @param initial the initial backoff-time in milliseconds
+     * @param increment the amount to increment the backoff-time with every step (in milliseconds)
+     * @param max the maximum backoff-time (in milliseconds), no bound if undefined
+     */
+    function LinearBackoff(initial, increment, max) {
+        this.i = 0;
+        this._retries = 0;
+        if (initial < 0) {
+            throw new Error("Initial must be a positive number or zero");
+        }
+        if (increment < 0) {
+            throw new Error("Increment must be a positive number or zero");
+        }
+        if (max !== undefined && max < 0) {
+            throw new Error("Max must be undefined, a positive number or zero");
+        }
+        if (max !== undefined && max < initial) {
+            throw new Error("Max must be undefined or greater than or equal to initial");
+        }
+        this.initial = initial;
+        this.increment = increment;
+        this.max = max;
+    }
+    Object.defineProperty(LinearBackoff.prototype, "retries", {
+        get: function () {
+            return this._retries;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LinearBackoff.prototype, "current", {
+        get: function () {
+            return this.max === undefined
+                ? this.initial + this.increment * this.i
+                : Math.min(this.initial + this.increment * this.i, this.max);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    LinearBackoff.prototype.next = function () {
+        this._retries++;
+        this.i++;
+        return this.current;
+    };
+    LinearBackoff.prototype.reset = function () {
+        this._retries = 0;
+        this.i = 0;
+    };
+    return LinearBackoff;
+}());
+exports.LinearBackoff = LinearBackoff;
+//# sourceMappingURL=linearbackoff.js.map

package/dist/cjs/src/backoff/linearbackoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linearbackoff.js","sourceRoot":"","sources":["../../../../src/backoff/linearbackoff.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IAOE;;;;;OAKG;IACH,uBAAY,OAAe,EAAE,SAAiB,EAAE,GAAY;QATpD,MAAC,GAAW,CAAC,CAAC;QACd,aAAQ,GAAW,CAAC,CAAC;QAS3B,IAAI,OAAO,GAAG,CAAC,EAAE;YACf,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;SAC9D;QACD,IAAI,SAAS,GAAG,CAAC,EAAE;YACjB,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;SAChE;QACD,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,GAAG,CAAC,EAAE;YAChC,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;SACrE;QACD,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,GAAG,OAAO,EAAE;YACtC,MAAM,IAAI,KAAK,CACb,2DAA2D,CAC5D,CAAC;SACH;QAED,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED,sBAAI,kCAAO;aAAX;YACE,OAAO,IAAI,CAAC,QAAQ,CAAC;QACvB,CAAC;;;OAAA;IAED,sBAAI,kCAAO;aAAX;YACE,OAAO,IAAI,CAAC,GAAG,KAAK,SAAS;gBAC3B,CAAC,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;gBACxC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;QACjE,CAAC;;;OAAA;IAED,4BAAI,GAAJ;QACE,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChB,IAAI,CAAC,CAAC,EAAE,CAAC;QACT,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,6BAAK,GAAL;QACE,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QAClB,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;IACb,CAAC;IACH,oBAAC;AAAD,CAAC,AAtDD,IAsDC;AAtDY,sCAAa"}

package/dist/cjs/src/index.d.ts

@@ -0,0 +1,14 @@
+export { Backoff } from "./backoff/backoff";
+export { ConstantBackoff } from "./backoff/constantbackoff";
+export { ExponentialBackoff } from "./backoff/exponentialbackoff";
+export { LinearBackoff } from "./backoff/linearbackoff";
+export { Queue } from "./queue/queue";
+export { ArrayQueue } from "./queue/array_queue";
+export { RingQueue } from "./queue/ring_queue";
+export { Websocket } from "./websocket";
+export { WebsocketBuffer } from "./websocket_buffer";
+export { WebsocketBuilder } from "./websocket_builder";
+export { WebsocketEvent, RetryEventDetail, ReconnectEventDetail, WebsocketEventMap, WebsocketEventListener, WebsocketEventListenerParams, WebsocketEventListenerOptions, WebsocketEventListenerWithOptions, WebsocketEventListeners, } from "./websocket_event";
+export { WebsocketOptions } from "./websocket_options";
+export { WebsocketConnectionRetryOptions } from "./websocket_retry_options";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EACjB,sBAAsB,EACtB,4BAA4B,EAC5B,6BAA6B,EAC7B,iCAAiC,EACjC,uBAAuB,GACxB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,+BAA+B,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/cjs/src/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebsocketEvent = exports.WebsocketBuilder = exports.Websocket = exports.RingQueue = exports.ArrayQueue = exports.LinearBackoff = exports.ExponentialBackoff = exports.ConstantBackoff = void 0;
+var constantbackoff_1 = require("./backoff/constantbackoff");
+Object.defineProperty(exports, "ConstantBackoff", { enumerable: true, get: function () { return constantbackoff_1.ConstantBackoff; } });
+var exponentialbackoff_1 = require("./backoff/exponentialbackoff");
+Object.defineProperty(exports, "ExponentialBackoff", { enumerable: true, get: function () { return exponentialbackoff_1.ExponentialBackoff; } });
+var linearbackoff_1 = require("./backoff/linearbackoff");
+Object.defineProperty(exports, "LinearBackoff", { enumerable: true, get: function () { return linearbackoff_1.LinearBackoff; } });
+var array_queue_1 = require("./queue/array_queue");
+Object.defineProperty(exports, "ArrayQueue", { enumerable: true, get: function () { return array_queue_1.ArrayQueue; } });
+var ring_queue_1 = require("./queue/ring_queue");
+Object.defineProperty(exports, "RingQueue", { enumerable: true, get: function () { return ring_queue_1.RingQueue; } });
+var websocket_1 = require("./websocket");
+Object.defineProperty(exports, "Websocket", { enumerable: true, get: function () { return websocket_1.Websocket; } });
+var websocket_builder_1 = require("./websocket_builder");
+Object.defineProperty(exports, "WebsocketBuilder", { enumerable: true, get: function () { return websocket_builder_1.WebsocketBuilder; } });
+var websocket_event_1 = require("./websocket_event");
+Object.defineProperty(exports, "WebsocketEvent", { enumerable: true, get: function () { return websocket_event_1.WebsocketEvent; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":";;;AACA,6DAA4D;AAAnD,kHAAA,eAAe,OAAA;AACxB,mEAAkE;AAAzD,wHAAA,kBAAkB,OAAA;AAC3B,yDAAwD;AAA/C,8GAAA,aAAa,OAAA;AAEtB,mDAAiD;AAAxC,yGAAA,UAAU,OAAA;AACnB,iDAA+C;AAAtC,uGAAA,SAAS,OAAA;AAClB,yCAAwC;AAA/B,sGAAA,SAAS,OAAA;AAElB,yDAAuD;AAA9C,qHAAA,gBAAgB,OAAA;AACzB,qDAU2B;AATzB,iHAAA,cAAc,OAAA"}

package/dist/cjs/src/queue/array_queue.d.ts

@@ -0,0 +1,17 @@
+import { Queue } from "./queue";
+/**
+ * An array queue is a queue that has an unbounded capacity. Reading from an array queue
+ * will return the oldest element and effectively remove it from the queue.
+ */
+export declare class ArrayQueue<E> implements Queue<E> {
+    private readonly elements;
+    constructor();
+    add(element: E): void;
+    clear(): void;
+    forEach(fn: (element: E) => unknown): void;
+    length(): number;
+    isEmpty(): boolean;
+    peek(): E | undefined;
+    read(): E | undefined;
+}
+//# sourceMappingURL=array_queue.d.ts.map

package/dist/cjs/src/queue/array_queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_queue.d.ts","sourceRoot":"","sources":["../../../../src/queue/array_queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC;;;GAGG;AACH,qBAAa,UAAU,CAAC,CAAC,CAAE,YAAW,KAAK,CAAC,CAAC,CAAC;IAC5C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAM;;IAM/B,GAAG,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI;IAIrB,KAAK;IAIL,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO;IAInC,MAAM,IAAI,MAAM;IAIhB,OAAO,IAAI,OAAO;IAIlB,IAAI,IAAI,CAAC,GAAG,SAAS;IAIrB,IAAI,IAAI,CAAC,GAAG,SAAS;CAGtB"}

package/dist/cjs/src/queue/array_queue.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayQueue = void 0;
+/**
+ * An array queue is a queue that has an unbounded capacity. Reading from an array queue
+ * will return the oldest element and effectively remove it from the queue.
+ */
+var ArrayQueue = /** @class */ (function () {
+    function ArrayQueue() {
+        this.elements = [];
+    }
+    ArrayQueue.prototype.add = function (element) {
+        this.elements.push(element);
+    };
+    ArrayQueue.prototype.clear = function () {
+        this.elements.length = 0;
+    };
+    ArrayQueue.prototype.forEach = function (fn) {
+        this.elements.forEach(fn);
+    };
+    ArrayQueue.prototype.length = function () {
+        return this.elements.length;
+    };
+    ArrayQueue.prototype.isEmpty = function () {
+        return this.elements.length === 0;
+    };
+    ArrayQueue.prototype.peek = function () {
+        return this.elements[0];
+    };
+    ArrayQueue.prototype.read = function () {
+        return this.elements.shift();
+    };
+    return ArrayQueue;
+}());
+exports.ArrayQueue = ArrayQueue;
+//# sourceMappingURL=array_queue.js.map

package/dist/cjs/src/queue/array_queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_queue.js","sourceRoot":"","sources":["../../../../src/queue/array_queue.ts"],"names":[],"mappings":";;;AAEA;;;GAGG;AACH;IAGE;QACE,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACrB,CAAC;IAED,wBAAG,GAAH,UAAI,OAAU;QACZ,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;IAED,0BAAK,GAAL;QACE,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;IAC3B,CAAC;IAED,4BAAO,GAAP,UAAQ,EAA2B;QACjC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAC5B,CAAC;IAED,2BAAM,GAAN;QACE,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;IAC9B,CAAC;IAED,4BAAO,GAAP;QACE,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC;IACpC,CAAC;IAED,yBAAI,GAAJ;QACE,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC1B,CAAC;IAED,yBAAI,GAAJ;QACE,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;IAC/B,CAAC;IACH,iBAAC;AAAD,CAAC,AAlCD,IAkCC;AAlCY,gCAAU"}

package/dist/cjs/src/queue/queue.d.ts

@@ -0,0 +1,41 @@
+/**
+ * A queue holds elements until they are read. The order in which elements are
+ * read is determined by the implementation of the queue.
+ */
+export interface Queue<E> {
+    /**
+     * Adds an element to the queue.
+     * @param element the element to add
+     */
+    add(element: E): void;
+    /**
+     * Clears the queue, removing all elements.
+     */
+    clear(): void;
+    /**
+     * Calls the given function for each element in the queue.
+     * @param fn the function to call
+     */
+    forEach(fn: (element: E) => unknown): void;
+    /**
+     * Number of elements in the queue.
+     * @return the number of elements in the queue
+     */
+    length(): number;
+    /**
+     * Whether the queue is empty.
+     * @return true if the queue is empty, false otherwise
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns the next element in the queue without removing it.
+     * @return the next element in the queue, or undefined if the queue is empty
+     */
+    peek(): E | undefined;
+    /**
+     * Removes and returns the next element in the queue.
+     * @return the next element in the queue, or undefined if the queue is empty
+     */
+    read(): E | undefined;
+}
+//# sourceMappingURL=queue.d.ts.map

package/dist/cjs/src/queue/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../../src/queue/queue.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC;IACtB;;;OAGG;IACH,GAAG,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC;IAEtB;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;;OAGG;IACH,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,GAAG,IAAI,CAAC;IAE3C;;;OAGG;IACH,MAAM,IAAI,MAAM,CAAC;IAEjB;;;OAGG;IACH,OAAO,IAAI,OAAO,CAAC;IAEnB;;;OAGG;IACH,IAAI,IAAI,CAAC,GAAG,SAAS,CAAC;IAEtB;;;OAGG;IACH,IAAI,IAAI,CAAC,GAAG,SAAS,CAAC;CACvB"}

package/dist/cjs/src/queue/queue.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=queue.js.map

package/dist/cjs/src/queue/queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../../../src/queue/queue.ts"],"names":[],"mappings":""}

package/dist/cjs/src/queue/ring_queue.d.ts

@@ -0,0 +1,20 @@
+import { Queue } from "./queue";
+/**
+ * A ring queue is a queue that has a fixed capacity. When the queue is full, the oldest element is
+ * removed to make room for the new element. Reading from a ring queue will return the oldest
+ * element and effectively remove it from the queue.
+ */
+export declare class RingQueue<E> implements Queue<E> {
+    private readonly elements;
+    private head;
+    private tail;
+    constructor(capacity: number);
+    add(element: E): void;
+    clear(): void;
+    forEach(fn: (element: E) => unknown): void;
+    length(): number;
+    isEmpty(): boolean;
+    peek(): E | undefined;
+    read(): E | undefined;
+}
+//# sourceMappingURL=ring_queue.d.ts.map

package/dist/cjs/src/queue/ring_queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ring_queue.d.ts","sourceRoot":"","sources":["../../../../src/queue/ring_queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC;;;;GAIG;AACH,qBAAa,SAAS,CAAC,CAAC,CAAE,YAAW,KAAK,CAAC,CAAC,CAAC;IAC3C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAM;IAC/B,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,IAAI,CAAS;gBAET,QAAQ,EAAE,MAAM;IAU5B,GAAG,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI;IAQrB,KAAK;IAKL,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO;IAUnC,MAAM,IAAI,MAAM;IAQhB,OAAO,IAAI,OAAO;IAIlB,IAAI,IAAI,CAAC,GAAG,SAAS;IAIrB,IAAI,IAAI,CAAC,GAAG,SAAS;CAOtB"}

package/dist/cjs/src/queue/ring_queue.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RingQueue = void 0;
+/**
+ * A ring queue is a queue that has a fixed capacity. When the queue is full, the oldest element is
+ * removed to make room for the new element. Reading from a ring queue will return the oldest
+ * element and effectively remove it from the queue.
+ */
+var RingQueue = /** @class */ (function () {
+    function RingQueue(capacity) {
+        if (!Number.isInteger(capacity) || capacity <= 0) {
+            throw new Error("Capacity must be a positive integer");
+        }
+        this.elements = new Array(capacity + 1); // +1 to distinguish between full and empty
+        this.head = 0;
+        this.tail = 0;
+    }
+    RingQueue.prototype.add = function (element) {
+        this.elements[this.head] = element;
+        this.head = (this.head + 1) % this.elements.length;
+        if (this.head === this.tail) {
+            this.tail = (this.tail + 1) % this.elements.length;
+        }
+    };
+    RingQueue.prototype.clear = function () {
+        this.head = 0;
+        this.tail = 0;
+    };
+    RingQueue.prototype.forEach = function (fn) {
+        for (var i = this.tail; i !== this.head; i = (i + 1) % this.elements.length) {
+            fn(this.elements[i]);
+        }
+    };
+    RingQueue.prototype.length = function () {
+        return this.tail === this.head
+            ? 0
+            : this.tail < this.head
+                ? this.head - this.tail
+                : this.elements.length - this.tail + this.head;
+    };
+    RingQueue.prototype.isEmpty = function () {
+        return this.head === this.tail;
+    };
+    RingQueue.prototype.peek = function () {
+        return this.isEmpty() ? undefined : this.elements[this.tail];
+    };
+    RingQueue.prototype.read = function () {
+        var e = this.peek();
+        if (e !== undefined) {
+            this.tail = (this.tail + 1) % this.elements.length;
+        }
+        return e;
+    };
+    return RingQueue;
+}());
+exports.RingQueue = RingQueue;
+//# sourceMappingURL=ring_queue.js.map

package/dist/cjs/src/queue/ring_queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ring_queue.js","sourceRoot":"","sources":["../../../../src/queue/ring_queue.ts"],"names":[],"mappings":";;;AAEA;;;;GAIG;AACH;IAKE,mBAAY,QAAgB;QAC1B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,QAAQ,IAAI,CAAC,EAAE;YAChD,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;SACxD;QAED,IAAI,CAAC,QAAQ,GAAG,IAAI,KAAK,CAAI,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,2CAA2C;QACvF,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;QACd,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;IAChB,CAAC;IAED,uBAAG,GAAH,UAAI,OAAU;QACZ,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC;QACnC,IAAI,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;QACnD,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE;YAC3B,IAAI,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;SACpD;IACH,CAAC;IAED,yBAAK,GAAL;QACE,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;QACd,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;IAChB,CAAC;IAED,2BAAO,GAAP,UAAQ,EAA2B;QACjC,KACE,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,EACjB,CAAC,KAAK,IAAI,CAAC,IAAI,EACf,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,EAClC;YACA,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;SACtB;IACH,CAAC;IAED,0BAAM,GAAN;QACE,OAAO,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI;YAC5B,CAAC,CAAC,CAAC;YACH,CAAC,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI;gBACvB,CAAC,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI;gBACvB,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IACnD,CAAC;IAED,2BAAO,GAAP;QACE,OAAO,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC;IACjC,CAAC;IAED,wBAAI,GAAJ;QACE,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/D,CAAC;IAED,wBAAI,GAAJ;QACE,IAAM,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,KAAK,SAAS,EAAE;YACnB,IAAI,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;SACpD;QACD,OAAO,CAAC,CAAC;IACX,CAAC;IACH,gBAAC;AAAD,CAAC,AA7DD,IA6DC;AA7DY,8BAAS"}