@vertexvis/utils 0.12.0-canary.9 → 0.12.0

package/dist/bundle.esm.js

@@ -1,6 +1,34 @@
 import { __awaiter, __generator, __assign, __extends, __read, __spreadArray, __values } from 'tslib';
 import crypto from 'crypto';
 
+/**
+ * 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 __awaiter(this, void 0, void 0, function () {
+        return __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++) {
@@ -33,28 +61,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 __awaiter(this, void 0, void 0, function () {
+        var ms, promise, timer_1, timeout_1, res;
+        return __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 ".concat(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 __awaiter(this, void 0, void 0, function () {
+        function execute(attempt, process, opts) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, delaysInMs, _b, maxRetries, delayInMs, e_1;
+                return __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 __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 __awaiter(this, void 0, void 0, function () {
+        var controller, pendingAbort, result;
+        return __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
 });
 
 /**
@@ -184,7 +316,7 @@ var isOpaque = function (color) {
  * `#`.
  */
 var toHexString = function (color) {
-    return "#" + componentToHex(color.r) + componentToHex(color.g) + componentToHex(color.b);
+    return "#".concat(componentToHex(color.r)).concat(componentToHex(color.g)).concat(componentToHex(color.b));
 };
 var componentToHex = function (num) {
     var hex = num.toString(16);
@@ -279,8 +411,9 @@ var color = /*#__PURE__*/Object.freeze({
 var MapperValidationError = /** @class */ (function (_super) {
     __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;
@@ -296,7 +429,7 @@ function required(name) {
             return input;
         }
         else {
-            return { errors: [name + " is required."] };
+            return { errors: ["".concat(name, " is required.")] };
         }
     };
 }
@@ -314,7 +447,7 @@ function requiredProp(prop) {
             return value;
         }
         else {
-            return { errors: [prop + " is required"] };
+            return { errors: ["".concat(prop, " is required")] };
         }
     };
 }
@@ -2845,7 +2978,7 @@ var isEqual = function (a, b) {
         queryA === queryB);
 };
 var replacePath = function (path, uri) {
-    var pathWithForwardSlash = path[0] === '/' ? path : "/" + path;
+    var pathWithForwardSlash = path[0] === '/' ? path : "/".concat(path);
     return __assign(__assign({}, uri), { path: pathWithForwardSlash });
 };
 var pathAsArray = function (uri) {
@@ -2921,17 +3054,17 @@ var queryAsMap = function (uri) {
 var toString = function (uri) {
     var result = '';
     if (uri.scheme != null && uri.scheme.length > 0) {
-        result = uri.scheme + ":";
+        result = "".concat(uri.scheme, ":");
     }
     if (uri.authority != null && uri.authority.length > 0) {
-        result += "//" + uri.authority;
+        result += "//".concat(uri.authority);
     }
     result += uri.path;
     if (uri.query != null && uri.query.length > 0) {
-        result += "?" + uri.query;
+        result += "?".concat(uri.query);
     }
     if (uri.fragment != null && uri.fragment.length > 0) {
-        result += "#" + uri.fragment;
+        result += "#".concat(uri.fragment);
     }
     return result;
 };
@@ -3116,10 +3249,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 __awaiter(this, void 0, void 0, function () {
+            var controller;
+            var _this = this;
+            return __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);
+                            }
+                        }, __assign(__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);
@@ -3133,5 +3306,5 @@ var EventDispatcher = /** @class */ (function () {
     return EventDispatcher;
 }());
 
-export { async as Async, binaryReader as BinaryReader, color as Color, EventDispatcher, mapper as Mapper, objects as Objects, range as Range, sets as Sets, strings as Strings, uuid as UUID, uri as Uri };
+export { async as Async, binaryReader as BinaryReader, color as Color, EventDispatcher, eventTargets as EventTargets, mapper as Mapper, objects as Objects, range as Range, sets as Sets, strings as Strings, uuid as UUID, uri as Uri };
 //# sourceMappingURL=bundle.esm.js.map