p-resolvify/dist/index.js

Handle promise rejection like resolved

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.resolvify = factory());
}(this, (function () { 'use strict';

  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
    });
  };

  return resolvify;

})));