@future-widget-lab/safe-ops/dist/safe-ops.esm.js

A set of helper functions for performing operations safely, preventing runtime errors from disrupting your application.

/**
 * @description
 * Use this helper to safely invoke a function and catch any errors that occur.
 */
var attempt = function attempt(fn) {
  try {
    return {
      ok: true,
      result: fn(),
      error: null
    };
  } catch (error) {
    return {
      ok: false,
      result: null,
      error: error
    };
  }
};

function asyncGeneratorStep(n, t, e, r, o, a, c) {
  try {
    var i = n[a](c),
      u = i.value;
  } catch (n) {
    return void e(n);
  }
  i.done ? t(u) : Promise.resolve(u).then(r, o);
}
function _asyncToGenerator(n) {
  return function () {
    var t = this,
      e = arguments;
    return new Promise(function (r, o) {
      var a = n.apply(t, e);
      function _next(n) {
        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
      }
      function _throw(n) {
        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
      }
      _next(void 0);
    });
  };
}
function _regeneratorRuntime() {
  _regeneratorRuntime = function () {
    return e;
  };
  var t,
    e = {},
    r = Object.prototype,
    n = r.hasOwnProperty,
    o = Object.defineProperty || function (t, e, r) {
      t[e] = r.value;
    },
    i = "function" == typeof Symbol ? Symbol : {},
    a = i.iterator || "@@iterator",
    c = i.asyncIterator || "@@asyncIterator",
    u = i.toStringTag || "@@toStringTag";
  function define(t, e, r) {
    return Object.defineProperty(t, e, {
      value: r,
      enumerable: !0,
      configurable: !0,
      writable: !0
    }), t[e];
  }
  try {
    define({}, "");
  } catch (t) {
    define = function (t, e, r) {
      return t[e] = r;
    };
  }
  function wrap(t, e, r, n) {
    var i = e && e.prototype instanceof Generator ? e : Generator,
      a = Object.create(i.prototype),
      c = new Context(n || []);
    return o(a, "_invoke", {
      value: makeInvokeMethod(t, r, c)
    }), a;
  }
  function tryCatch(t, e, r) {
    try {
      return {
        type: "normal",
        arg: t.call(e, r)
      };
    } catch (t) {
      return {
        type: "throw",
        arg: t
      };
    }
  }
  e.wrap = wrap;
  var h = "suspendedStart",
    l = "suspendedYield",
    f = "executing",
    s = "completed",
    y = {};
  function Generator() {}
  function GeneratorFunction() {}
  function GeneratorFunctionPrototype() {}
  var p = {};
  define(p, a, function () {
    return this;
  });
  var d = Object.getPrototypeOf,
    v = d && d(d(values([])));
  v && v !== r && n.call(v, a) && (p = v);
  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
  function defineIteratorMethods(t) {
    ["next", "throw", "return"].forEach(function (e) {
      define(t, e, function (t) {
        return this._invoke(e, t);
      });
    });
  }
  function AsyncIterator(t, e) {
    function invoke(r, o, i, a) {
      var c = tryCatch(t[r], t, o);
      if ("throw" !== c.type) {
        var u = c.arg,
          h = u.value;
        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
          invoke("next", t, i, a);
        }, function (t) {
          invoke("throw", t, i, a);
        }) : e.resolve(h).then(function (t) {
          u.value = t, i(u);
        }, function (t) {
          return invoke("throw", t, i, a);
        });
      }
      a(c.arg);
    }
    var r;
    o(this, "_invoke", {
      value: function (t, n) {
        function callInvokeWithMethodAndArg() {
          return new e(function (e, r) {
            invoke(t, n, e, r);
          });
        }
        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
      }
    });
  }
  function makeInvokeMethod(e, r, n) {
    var o = h;
    return function (i, a) {
      if (o === f) throw Error("Generator is already running");
      if (o === s) {
        if ("throw" === i) throw a;
        return {
          value: t,
          done: !0
        };
      }
      for (n.method = i, n.arg = a;;) {
        var c = n.delegate;
        if (c) {
          var u = maybeInvokeDelegate(c, n);
          if (u) {
            if (u === y) continue;
            return u;
          }
        }
        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
          if (o === h) throw o = s, n.arg;
          n.dispatchException(n.arg);
        } else "return" === n.method && n.abrupt("return", n.arg);
        o = f;
        var p = tryCatch(e, r, n);
        if ("normal" === p.type) {
          if (o = n.done ? s : l, p.arg === y) continue;
          return {
            value: p.arg,
            done: n.done
          };
        }
        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
      }
    };
  }
  function maybeInvokeDelegate(e, r) {
    var n = r.method,
      o = e.iterator[n];
    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
    var i = tryCatch(o, e.iterator, r.arg);
    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
    var a = i.arg;
    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
  }
  function pushTryEntry(t) {
    var e = {
      tryLoc: t[0]
    };
    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
  }
  function resetTryEntry(t) {
    var e = t.completion || {};
    e.type = "normal", delete e.arg, t.completion = e;
  }
  function Context(t) {
    this.tryEntries = [{
      tryLoc: "root"
    }], t.forEach(pushTryEntry, this), this.reset(!0);
  }
  function values(e) {
    if (e || "" === e) {
      var r = e[a];
      if (r) return r.call(e);
      if ("function" == typeof e.next) return e;
      if (!isNaN(e.length)) {
        var o = -1,
          i = function next() {
            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
            return next.value = t, next.done = !0, next;
          };
        return i.next = i;
      }
    }
    throw new TypeError(typeof e + " is not iterable");
  }
  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
    value: GeneratorFunctionPrototype,
    configurable: !0
  }), o(GeneratorFunctionPrototype, "constructor", {
    value: GeneratorFunction,
    configurable: !0
  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
    var e = "function" == typeof t && t.constructor;
    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
  }, e.mark = function (t) {
    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
  }, e.awrap = function (t) {
    return {
      __await: t
    };
  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
    return this;
  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
    void 0 === i && (i = Promise);
    var a = new AsyncIterator(wrap(t, r, n, o), i);
    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
      return t.done ? t.value : a.next();
    });
  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
    return this;
  }), define(g, "toString", function () {
    return "[object Generator]";
  }), e.keys = function (t) {
    var e = Object(t),
      r = [];
    for (var n in e) r.push(n);
    return r.reverse(), function next() {
      for (; r.length;) {
        var t = r.pop();
        if (t in e) return next.value = t, next.done = !1, next;
      }
      return next.done = !0, next;
    };
  }, e.values = values, Context.prototype = {
    constructor: Context,
    reset: function (e) {
      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
    },
    stop: function () {
      this.done = !0;
      var t = this.tryEntries[0].completion;
      if ("throw" === t.type) throw t.arg;
      return this.rval;
    },
    dispatchException: function (e) {
      if (this.done) throw e;
      var r = this;
      function handle(n, o) {
        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
      }
      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
        var i = this.tryEntries[o],
          a = i.completion;
        if ("root" === i.tryLoc) return handle("end");
        if (i.tryLoc <= this.prev) {
          var c = n.call(i, "catchLoc"),
            u = n.call(i, "finallyLoc");
          if (c && u) {
            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
          } else if (c) {
            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
          } else {
            if (!u) throw Error("try statement without catch or finally");
            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
          }
        }
      }
    },
    abrupt: function (t, e) {
      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
        var o = this.tryEntries[r];
        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
          var i = o;
          break;
        }
      }
      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
      var a = i ? i.completion : {};
      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
    },
    complete: function (t, e) {
      if ("throw" === t.type) throw t.arg;
      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
    },
    finish: function (t) {
      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
        var r = this.tryEntries[e];
        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
      }
    },
    catch: function (t) {
      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
        var r = this.tryEntries[e];
        if (r.tryLoc === t) {
          var n = r.completion;
          if ("throw" === n.type) {
            var o = n.arg;
            resetTryEntry(r);
          }
          return o;
        }
      }
      throw Error("illegal catch attempt");
    },
    delegateYield: function (e, r, n) {
      return this.delegate = {
        iterator: values(e),
        resultName: r,
        nextLoc: n
      }, "next" === this.method && (this.arg = t), y;
    }
  }, e;
}

/**
 * @description
 * Use this helper to safely invoke an async function and catch any errors that occur.
 */
var attemptAsync = /*#__PURE__*/function () {
  var _ref = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(fn) {
    return _regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          _context.prev = 0;
          _context.next = 3;
          return fn();
        case 3:
          _context.t0 = _context.sent;
          return _context.abrupt("return", {
            ok: true,
            result: _context.t0,
            error: null
          });
        case 7:
          _context.prev = 7;
          _context.t1 = _context["catch"](0);
          return _context.abrupt("return", {
            ok: false,
            result: null,
            error: _context.t1
          });
        case 10:
        case "end":
          return _context.stop();
      }
    }, _callee, null, [[0, 7]]);
  }));
  return function attemptAsync(_x) {
    return _ref.apply(this, arguments);
  };
}();

/**
 * @description
 * Use this helper determine whether all the members of an array satisfy the specified test.
 *
 * This function behaves similarly to `Array.prototype.every`, but with added error handling:
 * - If the predicate throws an error for any element, the error is handled via the onError callback.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array of items to test.
 * @param {Predicate<TInput>} predicate A function that tests each element of the array. Called once for each item in the array.
 * @param {{ onError?: OnError<TInput> }} options An optional object for error handling.
 *
 * @returns {boolean} Returns true if the predicate returns true for every element in the array. Otherwise, it returns false.
 */
var safeEvery = function safeEvery(collection, predicate, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    _options$onError = _options.onError,
    onError = _options$onError === void 0 ? function () {} : _options$onError;
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      var matches = predicate(item, index, collection);
      if (!matches) {
        return false;
      }
    } catch (error) {
      onError(error, item, index);
      return false;
    }
  }
  return true;
};

/**
 * @description
 * Use this helper determine whether all the members of an array satisfy the specified test.
 *
 * This function behaves similarly to `Array.prototype.every`, but with added error handling:
 * - If the predicate throws an error for any element, the error is handled via the onError callback.
 * - Collects errors in an array and returns it in the report.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array of items to test.
 * @param {Predicate<TInput>} predicate A function that tests each element of the array. Called once for each item in the array.
 * @param {{ onError?: OnError<TInput> }} options An optional object for error handling.
 *
 * @returns {{ result: boolean; errors: Array<ErrorReport<TInput>> }} A report which contains the result of the test and the errors that occurred.
 */
var safeEveryWithErrors = function safeEveryWithErrors(collection, predicate, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    _options$onError = _options.onError,
    onError = _options$onError === void 0 ? function () {} : _options$onError;
  var errors = [];
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      var matches = predicate(item, index, collection);
      if (!matches) {
        return {
          result: false,
          errors: errors
        };
      }
    } catch (error) {
      errors.push({
        error: error,
        item: item,
        index: index
      });
      onError(error, item, index);
      return {
        result: false,
        errors: errors
      };
    }
  }
  return {
    result: true,
    errors: errors
  };
};

/**
 * @description
 * Use this helper to return the elements of an array that meet the condition specified in a callback function.
 *
 * This function behaves similarly to `Array.prototype.filter`, but with added error handling:
 * - If the predicate throws an error for any element, the error is handled via the onError callback.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array of items to filter.
 * @param {Predicate<TInput>} predicate A function that tests each element of the array. Called once for each item in the array.
 * @param {{ onError?: OnError<TInput> }} options An optional object for error handling.
 *
 * @returns {Array<TInput>} An array of items that match the predicate.
 */
var safeFilter = function safeFilter(collection, predicate, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    _options$onError = _options.onError,
    onError = _options$onError === void 0 ? function () {} : _options$onError;
  var results = [];
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      var matches = predicate(item, index, collection);
      if (matches) {
        results.push(item);
      }
    } catch (error) {
      onError(error, item, index);
    }
  }
  return results;
};

/**
 * @description
 * Use this helper to return the elements of an array that meet the condition specified in a callback function.
 *
 * This function behaves similarly to `Array.prototype.filter`, but with added error handling:
 * - If the predicate throws an error for any element, the error is handled via the onError callback.
 * - Collects errors in an array and returns it in the report.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array of items to filter.
 * @param {Predicate<TInput>} predicate A function that tests each element of the array. Called once for each item in the array.
 * @param {{ onError?: OnError<TInput> }} options An optional object for error handling.
 *
 * @returns {{ results: Array<TInput>; errors: Array<ErrorReport<TInput>> }} A report which contains the array of items that match the predicate and the errors that occurred.
 */
var safeFilterWithErrors = function safeFilterWithErrors(collection, predicate, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    _options$onError = _options.onError,
    onError = _options$onError === void 0 ? function () {} : _options$onError;
  var results = [];
  var errors = [];
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      var matches = predicate(item, index, collection);
      if (matches) {
        results.push(item);
      }
    } catch (error) {
      errors.push({
        error: error,
        item: item,
        index: index
      });
      onError(error, item, index);
    }
  }
  return {
    results: results,
    errors: errors
  };
};

/**
 * @description
 * Use this helper to return the value of the first element in the array where predicate is true, and undefined.
 *
 * This function behaves similarly to `Array.prototype.find`, but with added error handling:
 * - If the predicate throws an error for any element, the error is handled via the onError callback.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array of items to search.
 * @param {Predicate<TInput>} predicate A function that tests each element of the array. Called once for each item in the array.
 * @param {{ onError?: OnError<TInput> }} options An optional object for error handling.
 *
 * @returns {TInput | undefined} The value of the first element in the array where predicate is true (and undefined if no such element is found).
 */
var safeFind = function safeFind(collection, predicate, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    _options$onError = _options.onError,
    onError = _options$onError === void 0 ? function () {} : _options$onError;
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      var matches = predicate(item, index, collection);
      if (matches) {
        return item;
      }
    } catch (error) {
      onError(error, item, index);
    }
  }
  return undefined;
};

/**
 * @description
 * Use this helper return the index of the first element in the array where predicate is true, and -1 otherwise.
 *
 * This function behaves similarly to `Array.prototype.findIndex`, but with added error handling:
 * - If the predicate throws an error for any element, the error is handled via the onError callback.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array of items to test.
 * @param {Predicate<TInput>} predicate A function that tests each element of the array. Called once for each item in the array.
 * @param {{ onError?: OnError<TInput> }} options An optional object for error handling.
 *
 * @returns {number} The index of the first element that satisfies the test. Returns -1 if no element matches.
 */
var safeFindIndex = function safeFindIndex(collection, predicate, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    _options$onError = _options.onError,
    onError = _options$onError === void 0 ? function () {} : _options$onError;
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      var matches = predicate(item, index, collection);
      if (matches) {
        return index;
      }
    } catch (error) {
      onError(error, item, index);
    }
  }
  return -1;
};

/**
 * @description
 * Use this helper return the index of the first element in the array where predicate is true, and -1 otherwise.
 *
 * This function behaves similarly to `Array.prototype.findIndex`, but with added error handling:
 * - If the predicate throws an error for any element, the error is handled via the onError callback.
 * - Collects errors in an array and returns it in the report.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array of items to test.
 * @param {Predicate<TInput>} predicate A function that tests each element of the array. Called once for each item in the array.
 * @param {{ onError?: OnError<TInput> }} options An optional object for error handling.
 *
 * @returns {{ index: number; errors: Array<ErrorReport<TInput>> }} The found index or -1 if not found, along with collected errors.
 */
var safeFindIndexWithErrors = function safeFindIndexWithErrors(collection, predicate, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    _options$onError = _options.onError,
    onError = _options$onError === void 0 ? function () {} : _options$onError;
  var errors = [];
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      var matches = predicate(item, index, collection);
      if (matches) {
        return {
          index: index,
          errors: errors
        };
      }
    } catch (error) {
      errors.push({
        error: error,
        item: item,
        index: index
      });
      onError(error, item, index);
    }
  }
  return {
    index: -1,
    errors: errors
  };
};

/**
 * @description
 * Use this helper to return the value of the first element in the array where predicate is true, and undefined.
 *
 * This function behaves similarly to `Array.prototype.find`, but with added error handling:
 * - If the predicate throws an error for any element, the error is handled via the onError callback.
 * - Collects errors in an array and returns it in the report.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array of items to search.
 * @param {Predicate<TInput>} predicate A function that tests each element of the array. Called once for each item in the array.
 * @param {{ onError?: OnError<TInput> }} options An optional object for error handling.
 *
 * @returns {{ found: TInput | undefined; errors: Array<ErrorReport<TInput>> }} A report which contains the value of the first element in the array where predicate is true (and undefined if no such element is found) and the errors that occurred.
 */
var safeFindWithErrors = function safeFindWithErrors(collection, predicate, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    onError = _options.onError;
  var errors = [];
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      var matches = predicate(item, index, collection);
      if (matches) {
        return {
          found: item,
          errors: errors
        };
      }
    } catch (error) {
      errors.push({
        error: error,
        item: item,
        index: index
      });
      onError == null || onError(error, item, index);
    }
  }
  return {
    found: undefined,
    errors: errors
  };
};

/**
 * @description
 * Use this helper to execute a function for each element in an array.
 *
 * This function behaves similarly to `Array.prototype.forEach`, but with added error handling:
 * - If the callback throws an error for any element, the error is handled via the onError callback.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array of items to iterate over.
 * @param {ForEachCallback<TInput>} callback The function to execute for each element.
 * @param {{ onError?: OnError<TInput> }} options An optional object for error handling.
 */
var safeForEach = function safeForEach(collection, callback, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    _options$onError = _options.onError,
    onError = _options$onError === void 0 ? function () {} : _options$onError;
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      callback(item, index, collection);
    } catch (error) {
      onError(error, item, index);
    }
  }
};

/**
 * @description
 * Use this helper to execute a function for each element in an array.
 *
 * This function behaves similarly to `Array.prototype.forEach`, but with added error handling:
 * - If the callback throws an error for any element, the error is handled via the onError callback.
 * - Collects errors in an array and returns it in the report.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array of items to iterate over.
 * @param {ForEachCallback<TInput>} callback The function to execute for each element.
 * @param {{ onError?: OnError<TInput> }} options An optional object for error handling.
 */
var safeForEachWithErrors = function safeForEachWithErrors(collection, callback, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    onError = _options.onError;
  var errors = [];
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      callback(item, index, collection);
    } catch (error) {
      errors.push({
        error: error,
        item: item,
        index: index
      });
      onError == null || onError(error, item, index);
    }
  }
  return {
    errors: errors
  };
};

/**
 * @description
 * Use this helper to safely parse a possibly faulty JSON object.
 */
var safeJsonParse = function safeJsonParse(input, fallback) {
  try {
    return !!input ? JSON.parse(input) : fallback;
  } catch (_unused) {
    return fallback;
  }
};

/**
 * @description
 * Use this helper to transform an array of items into a new array of items.
 *
 * This function behaves similarly to `Array.prototype.map`, but with added error handling:
 * - If the transformer throws an error for any element, the error is handled via the onError callback.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array of items to transform.
 * @param {Transformer<TInput>} transformer The function that transforms the items. Called once for each item in the array.
 * @param {{ onError?: OnError<TInput> }} options An optional object for error handling.
 *
 * @returns {Array<TOutput>} A new array with the results of the transformation.
 */
var safeMap = function safeMap(collection, transformer, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    onError = _options.onError;
  var results = [];
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      results.push(transformer(item, index, collection));
    } catch (error) {
      onError == null || onError(error, item, index);
    }
  }
  return results;
};

/**
 * @description
 * Use this helper to transform an array of items into a new array of items.
 *
 * This function behaves similarly to `Array.prototype.map`, but with added error handling:
 * - If the transformer throws an error for any element, the error is handled via the onError callback.
 * - Collects errors in an array and returns it in the report.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array of items to transform.
 * @param {Transformer<TInput>} transformer The function that transforms the items. Called once for each item in the array.
 * @param {{ onError?: OnError<TInput> }} options An optional object for error handling.
 *
 * @returns {{ results: Array<TOutput>; errors: Array<ErrorReport<TInput>> }} A report which contains the array of items that match the predicate and the errors that occurred.
 */
var safeMapWithErrors = function safeMapWithErrors(collection, transformer, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    onError = _options.onError;
  var results = [];
  var errors = [];
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      results.push(transformer(item, index, collection));
    } catch (error) {
      errors.push({
        error: error,
        item: item,
        index: index
      });
      onError == null || onError(error, item, index);
    }
  }
  return {
    results: results,
    errors: errors
  };
};

/**
 * @description
 * Use this helper to create an accumulated result given an array and an initial value.
 * - If the reducer throws an error for any element, the error is handled via the onError callback.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array to reduce.
 * @param {Reducer<TInput, TOutput>} reducer A function that processes each element.
 * @param {TOutput} initialValue The initial value for the accumulator.
 * @param {{ onError?: OnError<TInput> }} options Optional error handling configuration.
 *
 * @returns {TOutput} The accumulated result.
 */
var safeReduce = function safeReduce(collection, reducer, initialValue, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    _options$onError = _options.onError,
    onError = _options$onError === void 0 ? function () {} : _options$onError;
  var accumulator = initialValue;
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      accumulator = reducer(accumulator, item, index, collection);
    } catch (error) {
      onError(error, item, index);
    }
  }
  return accumulator;
};

/**
 * @description
 * Use this helper to create an accumulated result given an array and an initial value.
 * - If the reducer throws an error for any element, the error is handled via the onError callback.
 * - Collects errors in an array and returns it in the report.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array to reduce.
 * @param {Reducer<TInput, TOutput>} reducer A function that processes each element.
 * @param {TOutput} initialValue The initial value for the accumulator.
 * @param {{ onError?: OnError<TInput> }} options Optional error handling configuration.
 *
 * @returns {{ result: TOutput; errors: Array<ErrorReport<TInput>> }} An object containing the accumulated result and any errors encountered.
 */
var safeReduceWithErrors = function safeReduceWithErrors(collection, reducer, initialValue, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    _options$onError = _options.onError,
    onError = _options$onError === void 0 ? function () {} : _options$onError;
  var accumulator = initialValue;
  var errors = [];
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      accumulator = reducer(accumulator, item, index, collection);
    } catch (error) {
      errors.push({
        error: error,
        item: item,
        index: index
      });
      onError(error, item, index);
    }
  }
  return {
    result: accumulator,
    errors: errors
  };
};

/**
 * @description
 * Use this helper to determine whether at least one element in the array satisfies the specified test.
 *
 * This function behaves similarly to `Array.prototype.some`, but with added error handling:
 * - If the predicate throws an error for any element, the error is handled via the onError callback.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array of items to test.
 * @param {Predicate<TInput>} predicate A function that tests each element of the array. Called once for each item in the array.
 * @param {{ onError?: OnError<TInput> }} options An optional object for error handling.
 *
 * @returns {boolean} Returns true if the predicate returns true for at least one element in the array. Otherwise, it returns false.
 */
var safeSome = function safeSome(collection, predicate, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    _options$onError = _options.onError,
    onError = _options$onError === void 0 ? function () {} : _options$onError;
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      var matches = predicate(item, index, collection);
      if (matches) {
        return true;
      }
    } catch (error) {
      onError(error, item, index);
    }
  }
  return false;
};

/**
 * @description
 * Use this helper to determine whether at least one member of an array satisfies the specified test.
 *
 * This function behaves similarly to `Array.prototype.some`, but with added error handling:
 * - If the predicate throws an error for any element, the error is handled via the onError callback.
 * - Collects errors in an array and returns it in the report.
 * - Allows for custom error handling through the onError option.
 *
 * @param {Array<TInput>} collection The array of items to test.
 * @param {Predicate<TInput>} predicate A function that tests each element of the array. Called once for each item in the array.
 * @param {{ onError?: OnError<TInput> }} options An optional object for error handling.
 *
 * @returns {{ result: boolean; errors: Array<ErrorReport<TInput>> }} A report which contains the result of the test and the errors that occurred.
 */
var safeSomeWithErrors = function safeSomeWithErrors(collection, predicate, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options,
    _options$onError = _options.onError,
    onError = _options$onError === void 0 ? function () {} : _options$onError;
  var errors = [];
  for (var index = 0; index < collection.length; index++) {
    var item = collection[index];
    try {
      var matches = predicate(item, index, collection);
      if (matches) {
        return {
          result: true,
          errors: errors
        };
      }
    } catch (error) {
      errors.push({
        error: error,
        item: item,
        index: index
      });
      onError(error, item, index);
    }
  }
  return {
    result: false,
    errors: errors
  };
};

/**
 * @description
 * Use this helper to safeguard against falsey values.
 */
var safeguard = function safeguard(x) {
  return !!x;
};

export { attempt, attemptAsync, safeEvery, safeEveryWithErrors, safeFilter, safeFilterWithErrors, safeFind, safeFindIndex, safeFindIndexWithErrors, safeFindWithErrors, safeForEach, safeForEachWithErrors, safeJsonParse, safeMap, safeMapWithErrors, safeReduce, safeReduceWithErrors, safeSome, safeSomeWithErrors, safeguard };
//# sourceMappingURL=safe-ops.esm.js.map