@croct/sdk 0.10.0 → 0.11.0-alpha

package/channel/guaranteedChannel.js

@@ -1,80 +1,78 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GuaranteedChannel = exports.TimeStamper = void 0;
-var tslib_1 = require("tslib");
-var logging_1 = require("../logging");
-var TimeStamper = /** @class */ (function () {
-    function TimeStamper() {
-    }
-    TimeStamper.prototype.generate = function () {
+const logging_1 = require("../logging");
+class TimeStamper {
+    generate() {
         return String(Date.now());
-    };
-    return TimeStamper;
-}());
+    }
+}
 exports.TimeStamper = TimeStamper;
-var GuaranteedChannel = /** @class */ (function () {
-    function GuaranteedChannel(_a) {
-        var _b;
-        var channel = _a.channel, logger = _a.logger, stamper = _a.stamper, options = tslib_1.__rest(_a, ["channel", "logger", "stamper"]);
+class GuaranteedChannel {
+    constructor({ channel, logger, stamper, ...options }) {
+        var _a;
         this.closed = false;
         this.channel = channel;
         this.logger = logger !== null && logger !== void 0 ? logger : new logging_1.NullLogger();
         this.stamper = stamper;
-        this.options = tslib_1.__assign(tslib_1.__assign({}, options), { ackTimeout: (_b = options.ackTimeout) !== null && _b !== void 0 ? _b : 5000 });
+        this.options = {
+            ...options,
+            ackTimeout: (_a = options.ackTimeout) !== null && _a !== void 0 ? _a : 5000,
+        };
     }
-    GuaranteedChannel.prototype.publish = function (message) {
-        var _this = this;
+    publish(message) {
         if (this.closed) {
             return Promise.reject(new Error('Channel is closed.'));
         }
-        return new Promise(function (resolve, reject) {
-            var id = _this.stamper.generate(message);
-            var timeoutTimer;
-            var closeWatcher;
-            var confirmed = false;
-            var start = Date.now();
-            var acknowledge = function (response) {
+        return new Promise((resolve, reject) => {
+            const id = this.stamper.generate(message);
+            let timeoutTimer;
+            let closeWatcher;
+            let confirmed = false;
+            const start = Date.now();
+            const acknowledge = (response) => {
                 if (response === id) {
                     confirmed = true;
-                    var elapsed = Date.now() - start;
+                    const elapsed = Date.now() - start;
                     window.clearTimeout(timeoutTimer);
                     window.clearInterval(closeWatcher);
-                    _this.logger.debug("Delivery confirmed #".concat(id, ", elapsed ").concat(elapsed, "ms."));
-                    _this.channel.unsubscribe(acknowledge);
+                    this.logger.debug(`Delivery confirmed #${id}, elapsed ${elapsed}ms.`);
+                    this.channel.unsubscribe(acknowledge);
                     resolve();
                 }
             };
-            _this.channel.subscribe(acknowledge);
-            var abort = function (error) {
+            this.channel.subscribe(acknowledge);
+            const abort = (error) => {
                 window.clearTimeout(timeoutTimer);
                 window.clearInterval(closeWatcher);
-                _this.logger.error("Failed to send message #".concat(id));
-                _this.channel.unsubscribe(acknowledge);
+                this.logger.error(`Failed to send message #${id}`);
+                this.channel.unsubscribe(acknowledge);
                 reject(error);
             };
-            var wait = function () {
+            const wait = () => {
                 if (confirmed) {
                     return;
                 }
-                closeWatcher = window.setInterval(function () {
-                    if (_this.closed) {
+                closeWatcher = window.setInterval(() => {
+                    if (this.closed) {
                         // Cancel delay immediately when the channel is closed
                         abort(new Error('Connection deliberately closed.'));
                     }
                 }, 0);
-                _this.logger.debug("Waiting confirmation #".concat(id, "..."));
-                timeoutTimer = window.setTimeout(function () {
+                this.logger.debug(`Waiting confirmation #${id}...`);
+                timeoutTimer = window.setTimeout(() => {
                     abort(new Error('Maximum confirmation time reached.'));
-                }, _this.options.ackTimeout);
+                }, this.options.ackTimeout);
             };
-            _this.logger.debug("Sending message #".concat(id, "..."));
-            _this.channel.publish({ id: id, message: message }).then(wait, abort);
+            this.logger.debug(`Sending message #${id}...`);
+            this.channel
+                .publish({ id: id, message: message })
+                .then(wait, abort);
         });
-    };
-    GuaranteedChannel.prototype.close = function () {
+    }
+    close() {
         this.closed = true;
         return this.channel.close();
-    };
-    return GuaranteedChannel;
-}());
+    }
+}
 exports.GuaranteedChannel = GuaranteedChannel;

package/channel/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SocketChannel = exports.SandboxChannel = exports.RetryChannel = exports.QueuedChannel = exports.GuaranteedChannel = exports.EncodedChannel = exports.BeaconSocketChannel = void 0;
-var tslib_1 = require("tslib");
+const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./channel"), exports);
 var beaconSocketChannel_1 = require("./beaconSocketChannel");
 Object.defineProperty(exports, "BeaconSocketChannel", { enumerable: true, get: function () { return beaconSocketChannel_1.BeaconSocketChannel; } });

package/channel/queuedChannel.js

@@ -1,23 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueuedChannel = void 0;
-var tslib_1 = require("tslib");
-var logging_1 = require("../logging");
-var QueuedChannel = /** @class */ (function () {
-    function QueuedChannel(channel, queue, logger) {
+const logging_1 = require("../logging");
+class QueuedChannel {
+    constructor(channel, queue, logger) {
         this.closed = false;
         this.channel = channel;
         this.queue = queue;
         this.logger = logger !== null && logger !== void 0 ? logger : new logging_1.NullLogger();
     }
-    QueuedChannel.prototype.flush = function () {
+    flush() {
         if (this.pending === undefined) {
             return this.requeue();
         }
         return this.pending.catch(this.requeue.bind(this));
-    };
-    QueuedChannel.prototype.publish = function (message) {
-        var _this = this;
+    }
+    publish(message) {
         if (this.closed) {
             return Promise.reject(new Error('Channel is closed.'));
         }
@@ -31,22 +29,22 @@ var QueuedChannel = /** @class */ (function () {
                 : Promise.reject(new Error('The queue must be flushed.'));
         }
         this.enqueue(message);
-        this.pending = this.pending.then(function () { return _this.channel.publish(message).then(_this.dequeue.bind(_this)); });
+        this.pending = this.pending.then(() => this.channel
+            .publish(message)
+            .then(this.dequeue.bind(this)));
         return this.pending;
-    };
-    QueuedChannel.prototype.enqueue = function (message) {
+    }
+    enqueue(message) {
         this.logger.debug('Enqueueing message...');
-        this.logger.debug("Queue length: ".concat(this.queue.length() + 1));
+        this.logger.debug(`Queue length: ${this.queue.length() + 1}`);
         this.queue.push(message);
-    };
-    QueuedChannel.prototype.dequeue = function () {
+    }
+    dequeue() {
         this.logger.debug('Dequeuing message...');
-        this.logger.debug("Queue length: ".concat(Math.max(0, this.queue.length() - 1)));
+        this.logger.debug(`Queue length: ${Math.max(0, this.queue.length() - 1)}`);
         this.queue.shift();
-    };
-    QueuedChannel.prototype.requeue = function () {
-        var e_1, _a;
-        var _this = this;
+    }
+    requeue() {
         if (this.closed) {
             return Promise.reject(new Error('Channel is closed.'));
         }
@@ -54,54 +52,27 @@ var QueuedChannel = /** @class */ (function () {
         if (this.queue.isEmpty()) {
             return this.pending;
         }
-        var length = this.queue.length();
+        const length = this.queue.length();
         this.logger.debug('Requeuing messages...');
-        this.logger.debug("Queue length: ".concat(length));
-        var _loop_1 = function (message) {
-            this_1.pending = this_1.pending.then(function () { return _this.channel.publish(message).then(_this.dequeue.bind(_this)); });
-        };
-        var this_1 = this;
-        try {
-            for (var _b = tslib_1.__values(this.queue.all()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var message = _c.value;
-                _loop_1(message);
-            }
+        this.logger.debug(`Queue length: ${length}`);
+        for (const message of this.queue.all()) {
+            this.pending = this.pending.then(() => this.channel
+                .publish(message)
+                .then(this.dequeue.bind(this)));
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
+        return this.pending;
+    }
+    async close() {
+        this.closed = true;
+        await this.channel.close();
+        if (this.pending !== undefined) {
             try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                await this.pending;
+            }
+            catch {
+                // suppress errors
             }
-            finally { if (e_1) throw e_1.error; }
         }
-        return this.pending;
-    };
-    QueuedChannel.prototype.close = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _a;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        this.closed = true;
-                        return [4 /*yield*/, this.channel.close()];
-                    case 1:
-                        _b.sent();
-                        if (!(this.pending !== undefined)) return [3 /*break*/, 5];
-                        _b.label = 2;
-                    case 2:
-                        _b.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, this.pending];
-                    case 3:
-                        _b.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        _a = _b.sent();
-                        return [3 /*break*/, 5];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return QueuedChannel;
-}());
+    }
+}
 exports.QueuedChannel = QueuedChannel;

package/channel/retryChannel.d.ts

@@ -1,7 +1,7 @@
 import { OutputChannel } from './channel';
 import { Logger } from '../logging';
 import { RetryPolicy } from '../retry';
-declare type Configuration<T> = {
+type Configuration<T> = {
     channel: OutputChannel<T>;
     retryPolicy: RetryPolicy<T>;
     logger?: Logger;

package/channel/retryChannel.js

@@ -1,91 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RetryChannel = void 0;
-var tslib_1 = require("tslib");
-var logging_1 = require("../logging");
-var RetryChannel = /** @class */ (function () {
-    function RetryChannel(_a) {
-        var channel = _a.channel, retryPolicy = _a.retryPolicy, logger = _a.logger;
+const logging_1 = require("../logging");
+class RetryChannel {
+    constructor({ channel, retryPolicy, logger }) {
         this.closed = false;
         this.channel = channel;
         this.retryPolicy = retryPolicy;
         this.logger = logger !== null && logger !== void 0 ? logger : new logging_1.NullLogger();
     }
-    RetryChannel.prototype.publish = function (message) {
-        var _this = this;
+    publish(message) {
         if (this.closed) {
             return Promise.reject(new Error('The channel is closed.'));
         }
-        return this.channel.publish(message).catch(function (error) { return _this.retry(message, error); });
-    };
-    RetryChannel.prototype.retry = function (message, error) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var attempt, _loop_1, this_1, state_1;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        attempt = 0;
-                        _loop_1 = function () {
-                            var delay, _b, _c;
-                            return tslib_1.__generator(this, function (_d) {
-                                switch (_d.label) {
-                                    case 0:
-                                        if (this_1.closed) {
-                                            throw new Error('Connection deliberately closed.');
-                                        }
-                                        delay = this_1.retryPolicy.getDelay(attempt);
-                                        this_1.logger.debug("Retry attempt ".concat(attempt + 1));
-                                        if (!(delay > 0)) return [3 /*break*/, 2];
-                                        this_1.logger.debug("Retry attempt delayed in ".concat(delay, "ms"));
-                                        return [4 /*yield*/, new Promise(function (resolve, reject) {
-                                                var closeWatcher = window.setInterval(function () {
-                                                    if (_this.closed) {
-                                                        // Cancel delay immediately when the channel is closed
-                                                        window.clearInterval(closeWatcher);
-                                                        reject(new Error('Connection deliberately closed.'));
-                                                    }
-                                                }, 0);
-                                                window.setTimeout(function () {
-                                                    window.clearInterval(closeWatcher);
-                                                    resolve();
-                                                }, delay);
-                                            })];
-                                    case 1:
-                                        _d.sent();
-                                        _d.label = 2;
-                                    case 2:
-                                        _d.trys.push([2, 4, , 5]);
-                                        _b = {};
-                                        return [4 /*yield*/, this_1.channel.publish(message)];
-                                    case 3: return [2 /*return*/, (_b.value = _d.sent(), _b)];
-                                    case 4:
-                                        _c = _d.sent();
-                                        attempt += 1;
-                                        return [3 /*break*/, 5];
-                                    case 5: return [2 /*return*/];
-                                }
-                            });
-                        };
-                        this_1 = this;
-                        _a.label = 1;
-                    case 1:
-                        if (!this.retryPolicy.shouldRetry(attempt, message, error)) return [3 /*break*/, 3];
-                        return [5 /*yield**/, _loop_1()];
-                    case 2:
-                        state_1 = _a.sent();
-                        if (typeof state_1 === "object")
-                            return [2 /*return*/, state_1.value];
-                        return [3 /*break*/, 1];
-                    case 3: throw new Error('Maximum retry attempts reached.');
-                }
-            });
-        });
-    };
-    RetryChannel.prototype.close = function () {
+        return this.channel
+            .publish(message)
+            .catch(error => this.retry(message, error));
+    }
+    async retry(message, error) {
+        let attempt = 0;
+        while (this.retryPolicy.shouldRetry(attempt, message, error)) {
+            if (this.closed) {
+                throw new Error('Connection deliberately closed.');
+            }
+            const delay = this.retryPolicy.getDelay(attempt);
+            this.logger.debug(`Retry attempt ${attempt + 1}`);
+            if (delay > 0) {
+                this.logger.debug(`Retry attempt delayed in ${delay}ms`);
+                await new Promise((resolve, reject) => {
+                    const closeWatcher = window.setInterval(() => {
+                        if (this.closed) {
+                            // Cancel delay immediately when the channel is closed
+                            window.clearInterval(closeWatcher);
+                            reject(new Error('Connection deliberately closed.'));
+                        }
+                    }, 0);
+                    window.setTimeout(() => {
+                        window.clearInterval(closeWatcher);
+                        resolve();
+                    }, delay);
+                });
+            }
+            try {
+                return await this.channel.publish(message);
+            }
+            catch {
+                attempt += 1;
+            }
+        }
+        throw new Error('Maximum retry attempts reached.');
+    }
+    close() {
         this.closed = true;
         return this.channel.close();
-    };
-    return RetryChannel;
-}());
+    }
+}
 exports.RetryChannel = RetryChannel;

package/channel/sandboxChannel.js

@@ -1,37 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SandboxChannel = void 0;
-var SandboxChannel = /** @class */ (function () {
-    function SandboxChannel() {
+class SandboxChannel {
+    constructor() {
         this.listeners = [];
         this.messages = [];
         this.closed = false;
     }
-    SandboxChannel.prototype.publish = function (message) {
+    publish(message) {
         this.messages.push(message);
         return Promise.resolve();
-    };
-    SandboxChannel.prototype.notify = function (message) {
-        this.listeners.forEach(function (dispatch) { return dispatch(message); });
-    };
-    SandboxChannel.prototype.subscribe = function (listener) {
+    }
+    notify(message) {
+        this.listeners.forEach(dispatch => dispatch(message));
+    }
+    subscribe(listener) {
         if (!this.listeners.includes(listener)) {
             this.listeners.push(listener);
         }
-    };
-    SandboxChannel.prototype.unsubscribe = function (listener) {
-        var index = this.listeners.indexOf(listener);
+    }
+    unsubscribe(listener) {
+        const index = this.listeners.indexOf(listener);
         if (index >= 0) {
             this.listeners.splice(index, 1);
         }
-    };
-    SandboxChannel.prototype.close = function () {
+    }
+    close() {
         this.closed = true;
         return Promise.resolve();
-    };
-    SandboxChannel.prototype.isClosed = function () {
+    }
+    isClosed() {
         return this.closed;
-    };
-    return SandboxChannel;
-}());
+    }
+}
 exports.SandboxChannel = SandboxChannel;

package/channel/socketChannel.d.ts

@@ -1,14 +1,14 @@
 import { Logger } from '../logging';
 import { ChannelListener, DuplexChannel } from './channel';
-declare type Input = string | ArrayBufferLike | Blob | ArrayBufferView;
-declare type Output = string | ArrayBuffer | Blob;
-declare type Options = {
+type Input = string | ArrayBufferLike | Blob | ArrayBufferView;
+type Output = string | ArrayBuffer | Blob;
+type Options = {
     closeTimeout: number;
     connectionTimeout: number;
     protocols: string | string[];
     binaryType?: BinaryType;
 };
-export declare type Configuration = Partial<Options> & {
+export type Configuration = Partial<Options> & {
     url: string;
     logger?: Logger;
 };