@vertexvis/utils 0.12.0-canary.4 → 0.12.0-canary.43

package/dist/async.d.ts

@@ -25,3 +25,48 @@ export declare function timeout(ms: number): Promise<void>;
  * @param promise The promise to assign a timeout to.
  */
 export declare function timeout<T>(ms: number, promise: Promise<T>): Promise<T>;
+interface RetryOptions {
+    /**
+     * An array of delays that are used between each retry attempt.
+     */
+    delaysInMs?: number[];
+    /**
+     * The maximum number of retries that will be attempted.
+     */
+    maxRetries?: number;
+}
+/**
+ * Executes and reattempts execution of an asynchronous function if it throws an
+ * error. By default, this function will only retry once and reexecute
+ * immediately after the previous execution throws. You can configure the number
+ * of retry attempts and delays with the `maxRetries` and `delaysInMs` options.
+ *
+ * The `delaysInMs` is an array of delays in milliseconds for each retry
+ * attempt. If there are more retry attempts than delays, the last delay will be
+ * used.
+ *
+ * @param process The process to execute.
+ * @param opts Options to configure retry behavior.
+ * @returns A promise that resolves with a successful value, or the original
+ *  rejected value if the process fails.
+ */
+export declare function retry<T>(process: () => Promise<T>, opts?: RetryOptions): Promise<T>;
+/**
+ * Returns a promise that either resolves with the result of `promise`, or a
+ * value that indicates the execution was aborted.
+ *
+ * **Note:** Because Promises in JS cannot be canceled, an abort signal will not
+ * cancel the execution of the promise.
+ *
+ * @param signal A signal that communicates the process should be aborted.
+ * @param promise A promise who's value will be returned if not aborted.
+ * @returns A value indicating if the process was aborted, or the value of
+ * `promise`.
+ */
+export declare function abort<T>(signal: AbortSignal, promise: Promise<T>): Promise<{
+    aborted: true;
+} | {
+    aborted: false;
+    result: T;
+}>;
+export {};

package/dist/browser.cjs.js

@@ -4,6 +4,34 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
 
+/**
+ * Adds a listener to the given `target`, and returns a promise that
+ * resolves with the first event emitted of the given `type`.
+ *
+ * @param target The target to add an event listener to.
+ * @param type The event type to listen for.
+ * @param opts Options to pass to `addEventListener`.
+ * @returns A promise that resolves with the first event emitted of `type`.
+ */
+function once(target, type, opts) {
+    return tslib.__awaiter(this, void 0, void 0, function () {
+        return tslib.__generator(this, function (_a) {
+            return [2 /*return*/, new Promise(function (resolve) {
+                    function handler(event) {
+                        target.removeEventListener(type, handler);
+                        resolve(event);
+                    }
+                    target.addEventListener(type, handler, opts);
+                })];
+        });
+    });
+}
+
+var eventTargets = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  once: once
+});
+
 function delay() {
     var args = [];
     for (var _i = 0; _i < arguments.length; _i++) {
@@ -36,28 +64,132 @@ function timeout() {
     for (var _i = 0; _i < arguments.length; _i++) {
         args[_i] = arguments[_i];
     }
-    var ms = args[0];
-    if (typeof ms === 'number') {
-        var promise = args[1];
-        var timeout_1 = new Promise(function (_, reject) {
-            return setTimeout(function () { return reject(new Error("Promise timed out after " + ms + "ms")); }, ms);
+    return tslib.__awaiter(this, void 0, void 0, function () {
+        var ms, promise, timer_1, timeout_1, res;
+        return tslib.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ms = args[0];
+                    if (!(typeof ms === 'number')) return [3 /*break*/, 4];
+                    promise = args[1];
+                    timeout_1 = new Promise(function (_, reject) {
+                        timer_1 = setTimeout(function () { return reject(new Error("Promise timed out after " + ms + "ms")); }, ms);
+                    });
+                    if (!(promise != null)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, Promise.race([promise, timeout_1])];
+                case 1:
+                    res = _a.sent();
+                    clearTimeout(timer_1);
+                    return [2 /*return*/, res];
+                case 2: return [2 /*return*/, timeout_1];
+                case 3: return [3 /*break*/, 5];
+                case 4: return [2 /*return*/, Promise.reject('First argument to `timeout` must be a number')];
+                case 5: return [2 /*return*/];
+            }
         });
-        if (promise != null) {
-            return Promise.race([promise, timeout_1]);
-        }
-        else {
-            return timeout_1;
+    });
+}
+/**
+ * Executes and reattempts execution of an asynchronous function if it throws an
+ * error. By default, this function will only retry once and reexecute
+ * immediately after the previous execution throws. You can configure the number
+ * of retry attempts and delays with the `maxRetries` and `delaysInMs` options.
+ *
+ * The `delaysInMs` is an array of delays in milliseconds for each retry
+ * attempt. If there are more retry attempts than delays, the last delay will be
+ * used.
+ *
+ * @param process The process to execute.
+ * @param opts Options to configure retry behavior.
+ * @returns A promise that resolves with a successful value, or the original
+ *  rejected value if the process fails.
+ */
+function retry(process, opts) {
+    if (opts === void 0) { opts = {}; }
+    return tslib.__awaiter(this, void 0, void 0, function () {
+        function execute(attempt, process, opts) {
+            return tslib.__awaiter(this, void 0, void 0, function () {
+                var _a, delaysInMs, _b, maxRetries, delayInMs, e_1;
+                return tslib.__generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            _a = opts.delaysInMs, delaysInMs = _a === void 0 ? [] : _a, _b = opts.maxRetries, maxRetries = _b === void 0 ? 1 : _b;
+                            _c.label = 1;
+                        case 1:
+                            _c.trys.push([1, 4, , 8]);
+                            delayInMs = attempt === 0 || delaysInMs.length === 0
+                                ? 0
+                                : delaysInMs[Math.min(attempt - 1, delaysInMs.length - 1)];
+                            return [4 /*yield*/, delay(delayInMs)];
+                        case 2:
+                            _c.sent();
+                            return [4 /*yield*/, process()];
+                        case 3: return [2 /*return*/, _c.sent()];
+                        case 4:
+                            e_1 = _c.sent();
+                            if (!(attempt < maxRetries)) return [3 /*break*/, 6];
+                            return [4 /*yield*/, execute(attempt + 1, process, opts)];
+                        case 5: return [2 /*return*/, _c.sent()];
+                        case 6: throw e_1;
+                        case 7: return [3 /*break*/, 8];
+                        case 8: return [2 /*return*/];
+                    }
+                });
+            });
         }
+        return tslib.__generator(this, function (_a) {
+            return [2 /*return*/, execute(0, process, opts)];
+        });
+    });
+}
+/**
+ * Returns a promise that either resolves with the result of `promise`, or a
+ * value that indicates the execution was aborted.
+ *
+ * **Note:** Because Promises in JS cannot be canceled, an abort signal will not
+ * cancel the execution of the promise.
+ *
+ * @param signal A signal that communicates the process should be aborted.
+ * @param promise A promise who's value will be returned if not aborted.
+ * @returns A value indicating if the process was aborted, or the value of
+ * `promise`.
+ */
+function abort(signal, promise) {
+    return tslib.__awaiter(this, void 0, void 0, function () {
+        var controller, pendingAbort, result;
+        return tslib.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    controller = new AbortController();
+                    pendingAbort = once(signal, 'abort', { signal: controller.signal });
+                    return [4 /*yield*/, Promise.race([promise, pendingAbort])];
+                case 1:
+                    result = _a.sent();
+                    if (isAbortEvent(result)) {
+                        return [2 /*return*/, { aborted: true }];
+                    }
+                    else {
+                        controller.abort();
+                        return [2 /*return*/, { aborted: false, result: result }];
+                    }
+            }
+        });
+    });
+}
+function isAbortEvent(obj) {
+    if (obj instanceof Event) {
+        return obj.type === 'abort';
     }
-    else {
-        return Promise.reject('First argument to `timeout` must be a number');
-    }
+    else
+        return false;
 }
 
 var async = /*#__PURE__*/Object.freeze({
   __proto__: null,
   delay: delay,
-  timeout: timeout
+  timeout: timeout,
+  retry: retry,
+  abort: abort
 });
 
 /**
@@ -282,8 +414,9 @@ var color = /*#__PURE__*/Object.freeze({
 var MapperValidationError = /** @class */ (function (_super) {
     tslib.__extends(MapperValidationError, _super);
     function MapperValidationError(errors) {
-        var _this = _super.call(this, 'Validation error while mapping object.') || this;
+        var _this = _super.call(this, 'Validation error mapping object.') || this;
         _this.errors = errors;
+        Object.setPrototypeOf(_this, MapperValidationError.prototype);
         return _this;
     }
     return MapperValidationError;
@@ -3128,10 +3261,50 @@ var EventDispatcher = /** @class */ (function () {
     function EventDispatcher() {
         this.listeners = [];
     }
-    EventDispatcher.prototype.on = function (listener) {
+    EventDispatcher.prototype.on = function (listener, opts) {
         var _this = this;
+        var _a;
+        if (opts === void 0) { opts = {}; }
         this.listeners.push(listener);
-        return { dispose: function () { return _this.off(listener); } };
+        var controller = new AbortController();
+        controller.signal.addEventListener('abort', function () { return _this.off(listener); });
+        (_a = opts.abort) === null || _a === void 0 ? void 0 : _a.addEventListener('abort', function () { return controller.abort(); });
+        return { dispose: function () { return controller.abort(); } };
+    };
+    EventDispatcher.prototype.once = function (opts) {
+        var _this = this;
+        if (opts === void 0) { opts = {}; }
+        return new Promise(function (resolve) {
+            _this.on(function (event) { return resolve(event); }, opts);
+        });
+    };
+    EventDispatcher.prototype.onceWhen = function (predicate, opts) {
+        var _a;
+        if (opts === void 0) { opts = {}; }
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            var controller;
+            var _this = this;
+            return tslib.__generator(this, function (_b) {
+                controller = new AbortController();
+                (_a = opts.abort) === null || _a === void 0 ? void 0 : _a.addEventListener('abort', function () { return controller.abort(); });
+                return [2 /*return*/, new Promise(function (resolve) {
+                        _this.when(predicate, function (event) {
+                            if (predicate(event)) {
+                                controller.abort();
+                                resolve(event);
+                            }
+                        }, tslib.__assign(tslib.__assign({}, opts), { abort: controller.signal }));
+                    })];
+            });
+        });
+    };
+    EventDispatcher.prototype.when = function (predicate, listener, opts) {
+        if (opts === void 0) { opts = {}; }
+        return this.on(function (event) {
+            if (predicate(event)) {
+                listener(event);
+            }
+        }, opts);
     };
     EventDispatcher.prototype.off = function (listener) {
         var index = this.listeners.indexOf(listener);
@@ -3149,6 +3322,7 @@ exports.Async = async;
 exports.BinaryReader = binaryReader;
 exports.Color = color;
 exports.EventDispatcher = EventDispatcher;
+exports.EventTargets = eventTargets;
 exports.Mapper = mapper;
 exports.Objects = objects;
 exports.Range = range;