p-resolvify/dist/index.mjs

Handle promise rejection like resolved

function _await(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

var identity = function identity(x) {
  return x;
};

function _catch(body, recover) {
  try {
    var result = body();
  } catch (e) {
    return recover(e);
  }

  if (result && result.then) {
    return result.then(void 0, recover);
  }

  return result;
}

function _async(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

function resolvifyFunction(original, _ref) {
  var handler = _ref.handler,
      to = _ref.to;
  return _async(function () {
    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
      arguments_[_key] = arguments[_key];
    }

    return _catch(function () {
      return _await(original.apply(void 0, arguments_), function (result) {
        return to ? [undefined, result] : result;
      });
    }, function (error) {
      var handled = handler(error);
      return to ? [handled] : handled;
    });
  });
}

function resolvify(original, options) {
  options = Object.assign({
    handler: identity,
    to: false
  }, options);

  if (typeof original === 'function') {
    return resolvifyFunction(original, options);
  }

  return resolvifyFunction(function () {
    return original;
  }, options)();
}

resolvify.to = function to(original) {
  return resolvify(original, {
    to: true
  });
};

export { resolvify as default };