@vertexvis/utils 0.12.0-canary.6 → 0.12.0

package/dist/bundle.cjs.js

@@ -9,6 +9,34 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var crypto__default = /*#__PURE__*/_interopDefaultLegacy(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 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++) {
@@ -41,28 +69,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 ".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 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
 });
 
 /**
@@ -192,7 +324,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);
@@ -287,8 +419,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;
@@ -304,7 +437,7 @@ function required(name) {
             return input;
         }
         else {
-            return { errors: [name + " is required."] };
+            return { errors: ["".concat(name, " is required.")] };
         }
     };
 }
@@ -322,7 +455,7 @@ function requiredProp(prop) {
             return value;
         }
         else {
-            return { errors: [prop + " is required"] };
+            return { errors: ["".concat(prop, " is required")] };
         }
     };
 }
@@ -2853,7 +2986,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 tslib.__assign(tslib.__assign({}, uri), { path: pathWithForwardSlash });
 };
 var pathAsArray = function (uri) {
@@ -2929,17 +3062,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;
 };
@@ -3124,10 +3257,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);
@@ -3145,6 +3318,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;