ramda-adjunct 2.34.0

package/lib/allEqual.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _lengthLte = _interopRequireDefault(require("./lengthLte"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+// Original idea for this function was conceived by https://github.com/jackmellis
+// in https://github.com/char0n/ramda-adjunct/pull/513.
+
+/**
+ * Returns true if all items in the list are equivalent using `R.equals` for equality comparisons.
+ *
+ * @func allEqual
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.9.0|v2.9.0}
+ * @category List
+ * @sig [a] -> Boolean
+ * @param {Array} list The list of values
+ * @return {boolean}
+ * @see {@link https://ramdajs.com/docs/#equals|equals}
+ * @example
+ *
+ * RA.allEqual([ 1, 2, 3, 4 ]); //=> false
+ * RA.allEqual([ 1, 1, 1, 1 ]); //=> true
+ * RA.allEqual([]); //=> true
+ *
+ */
+var allEqual = (0, _ramda.curryN)(1, (0, _ramda.pipe)(_ramda.uniq, (0, _lengthLte["default"])(1)));
+var _default = allEqual;
+exports["default"] = _default;

package/lib/allEqualTo.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns true if all items in the list are equivalent to user provided value using `R.equals` for equality comparisons.
+ *
+ * @func allEqualTo
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.11.0|v2.11.0}
+ * @category List
+ * @sig a -> [b] -> Boolean
+ * @param {*} val User provided value to check the `list` against
+ * @param {Array} list The list of values
+ * @return {boolean}
+ * @see {@link RA.allEqual|allEqual}, {@link https://ramdajs.com/docs/#equals|equals}
+ * @example
+ *
+ * RA.allEqualTo(1, [ 1, 2, 3, 4 ]); //=> false
+ * RA.allEqualTo(1, [ 1, 1, 1, 1 ]); //=> true
+ * RA.allEqualTo({}, [ {}, {} ]); //=> true
+ * RA.allEqualTo(1, []); //=> true
+ *
+ */
+var allEqualTo = (0, _ramda.curry)(function (val, list) {
+  return (0, _ramda.all)((0, _ramda.equals)(val), list);
+});
+var _default = allEqualTo;
+exports["default"] = _default;

package/lib/allIdentical.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _lengthLte = _interopRequireDefault(require("./lengthLte"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Returns true if all items in the list are equivalent using `R.identical` for equality comparisons.
+ *
+ * @func allIdentical
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.11.0|v2.11.0}
+ * @category List
+ * @sig [a] -> Boolean
+ * @param {Array} list The list of values
+ * @return {boolean}
+ * @see {@link https://ramdajs.com/docs/#identical|identical}
+ * @example
+ *
+ * RA.allIdentical([ 1, 2, 3, 4 ]); //=> false
+ * RA.allIdentical([ 1, 1, 1, 1 ]); //=> true
+ * RA.allIdentical([]); //=> true
+ * RA.allIdentical([ {}, {} ]); //=> false
+ * RA.allIdentical([ () => {}, () => {} ]); //=> false
+ */
+var allIdentical = (0, _ramda.curryN)(1, (0, _ramda.pipe)((0, _ramda.uniqWith)(_ramda.identical), (0, _lengthLte["default"])(1)));
+var _default = allIdentical;
+exports["default"] = _default;

package/lib/allIdenticalTo.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns true if all items in the list are equivalent to user provided value using `R.identical` for equality comparisons.
+ *
+ * @func allIdenticalTo
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.11.0|v2.11.0}
+ * @category List
+ * @sig a -> [b] -> Boolean
+ * @param {*} val User provided value to check the `list` against
+ * @param {Array} list The list of values
+ * @return {boolean}
+ * @see {@link RA.allIdentical|allIdentical}, {@link http://ramdajs.com/docs/#identical|R.identical}
+ * @example
+ *
+ * RA.allIdenticalTo(1, [ 1, 2, 3, 4 ]); //=> false
+ * RA.allIdenticalTo(1, [ 1, 1, 1, 1 ]); //=> true
+ * RA.allIdenticalTo(1, []); //=> true
+ * RA.allIdenticalTo({}, [ {}, {} ]); //=> false
+ *
+ */
+var allIdenticalTo = (0, _ramda.curry)(function (val, list) {
+  return (0, _ramda.all)((0, _ramda.identical)(val), list);
+});
+var _default = allIdenticalTo;
+exports["default"] = _default;

package/lib/allP.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Composable shortcut for `Promise.all`.
+ *
+ * The `allP` method returns a single Promise that resolves when all of the promises
+ * in the iterable argument have resolved or when the iterable argument contains no promises.
+ * It rejects with the reason of the first promise that rejects.
+ *
+ * @func allP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.3.0|v2.3.0}
+ * @category Function
+ * @sig [Promise a] -> Promise [a]
+ * @param {Iterable.<*>} iterable An iterable object such as an Array or String
+ * @return {Promise} An already resolved Promise if the iterable passed is empty. An asynchronously resolved Promise if the iterable passed contains no promises. Note, Google Chrome 58 returns an already resolved promise in this case. A pending Promise in all other cases. This returned promise is then resolved/rejected asynchronously (as soon as the stack is empty) when all the promises in the given iterable have resolved, or if any of the promises reject. See the example about "Asynchronicity or synchronicity of allP" below.
+ * @see {@link RA.resolveP|resolveP}, {@link RA.rejectP|rejectP}
+ * @example
+ *
+ * RA.allP([1, 2]); //=> Promise([1, 2])
+ * RA.allP([1, Promise.resolve(2)]); //=> Promise([1, 2])
+ * RA.allP([Promise.resolve(1), Promise.resolve(2)]); //=> Promise([1, 2])
+ * RA.allP([1, Promise.reject(2)]); //=> Promise(2)
+ */
+var allP = (0, _ramda.curryN)(1, (0, _ramda.bind)(Promise.all, Promise));
+var _default = allP;
+exports["default"] = _default;

package/lib/allSettledP.js

@@ -0,0 +1,41 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.allSettledPPonyfill = void 0;
+
+var _ramda = require("ramda");
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+var _Promise = _interopRequireDefault(require("./internal/ponyfills/Promise.allSettled"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var allSettledPPonyfill = (0, _ramda.curryN)(1, _Promise["default"]);
+/**
+ * Returns a promise that is fulfilled with an array of promise state snapshots,
+ * but only after all the original promises have settled, i.e. become either fulfilled or rejected.
+ * We say that a promise is settled if it is not pending, i.e. if it is either fulfilled or rejected.
+ *
+ * @func allSettledP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.18.0|v2.18.0}
+ * @category Function
+ * @typedef Settlement = { status: String, value: * }
+ * @sig [Promise a] -> Promise [Settlement a]
+ * @param {Iterable.<*>} iterable An iterable object such as an Array or String
+ * @return {Promise} Returns a promise that is fulfilled with an array of promise state snapshots
+ * @see {@link RA.allP|allP}
+ * @example
+ *
+ * RA.allSettledP([
+ *   Promise.resolve(1),
+ *   2,
+ *   Promise.reject(3),
+ * ]); //=> Promise([{ status: 'fulfilled', value: 1 }, { status: 'fulfilled', value: 2 }, { status: 'rejected', reason: 3 }])
+ */
+
+exports.allSettledPPonyfill = allSettledPPonyfill;
+var allSettledP = (0, _isFunction["default"])(Promise.allSettled) ? (0, _ramda.curryN)(1, (0, _ramda.bind)(Promise.allSettled, Promise)) : allSettledPPonyfill;
+var _default = allSettledP;
+exports["default"] = _default;

package/lib/allUnique.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _lengthEq = _interopRequireDefault(require("./lengthEq"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Returns true if all items in the list are unique. `R.equals` is used to determine equality.
+ *
+ * @func allUnique
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category List
+ * @sig [a] -> Boolean
+ * @param {Array} list The list of values
+ * @return {boolean}
+ * @see {@link RA.notAllUnique|notAllUnique},  {@link https://ramdajs.com/docs/#equals|equals}
+ * @example
+ *
+ * RA.allUnique([ 1, 2, 3, 4 ]); //=> true
+ * RA.allUnique([ 1, 1, 2, 3 ]); //=> false
+ * RA.allUnique([]); //=> true
+ *
+ */
+var allUnique = (0, _ramda.converge)(_lengthEq["default"], [_ramda.length, _ramda.uniq]);
+var _default = allUnique;
+exports["default"] = _default;

package/lib/anyP.js

@@ -0,0 +1,47 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+exports.__esModule = true;
+exports["default"] = exports.anyPPonyfill = void 0;
+
+var _ramda = require("ramda");
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+var _Promise = _interopRequireWildcard(require("./internal/ponyfills/Promise.any"));
+
+exports.AggregatedError = _Promise.AggregatedError;
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var anyPPonyfill = (0, _ramda.curryN)(1, _Promise["default"]);
+exports.anyPPonyfill = anyPPonyfill;
+
+/**
+ * Returns a promise that is fulfilled by the first given promise to be fulfilled,
+ * or rejected with an array of rejection reasons if all of the given promises are rejected.
+ *
+ * @func anyP
+ * @memberOf RA
+ * @category Function
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @sig [Promise a] -> Promise a
+ * @param {Iterable.<*>} iterable An iterable object such as an Array or String
+ * @return {Promise} A promise that is fulfilled by the first given promise to be fulfilled, or rejected with an array of rejection reasons if all of the given promises are rejected
+ * @see {@link RA.lastP|lastP}
+ * @example
+ *
+ * RA.anyP([
+ *   Promise.resolve(1),
+ *   2,
+ *   Promise.reject(3),
+ * ]); //=> Promise(1)
+ */
+var anyP = (0, _isFunction["default"])(Promise.any) ? (0, _ramda.curryN)(1, (0, _ramda.bind)(Promise.any, Promise)) : anyPPonyfill;
+var _default = anyP;
+exports["default"] = _default;

package/lib/appendFlipped.js

@@ -0,0 +1,29 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns a new list containing the contents of the given list, followed by the given element.
+ * Like {@link http://ramdajs.com/docs/#append|R.append} but with argument order reversed.
+ *
+ * @func appendFlipped
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
+ * @category List
+ * @sig [a] -> a -> [a]
+ * @param {Array} list The list of elements to add a new item to
+ * @param {*} el The element to add to the end of the new list
+ * @return {Array} A new list containing the elements of the old list followed by `el`
+ * @see {@link http://ramdajs.com/docs/#append|R.append}
+ * @example
+ *
+ * RA.appendFlipped(['write', 'more'], 'tests'); //=> ['write', 'more', 'tests']
+ * RA.appendFlipped([], 'tests'); //=> ['tests']
+ * RA.appendFlipped(['write', 'more'], ['tests']); //=> ['write', 'more', ['tests']]
+ */
+var appendFlipped = (0, _ramda.flip)(_ramda.append);
+var _default = appendFlipped;
+exports["default"] = _default;

package/lib/argsPass.js

@@ -0,0 +1,48 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _list = _interopRequireDefault(require("./list"));
+
+var _isTruthy = _interopRequireDefault(require("./isTruthy"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Takes a combining predicate and a list of functions and returns a function which will map the
+ * arguments it receives to the list of functions and returns the result of passing the values
+ * returned from each function to the combining predicate. A combining predicate is a function that
+ * combines a list of Boolean values into a single Boolean value, such as `R.any` or `R.all`. It
+ * will test each value using `RA.isTruthy`, meaning the functions don't necessarily have to be
+ * predicates.
+ *
+ * The function returned is curried to the number of functions supplied, and if called with more
+ * arguments than functions, any remaining arguments are passed in to the combining predicate
+ * untouched.
+ *
+ * @func argsPass
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.7.0|v2.7.0}
+ * @category Logic
+ * @sig ((* -> Boolean) -> [*] -> Boolean) -> [(* -> Boolean), ...] -> (*...) -> Boolean
+ * @param {Function} combiningPredicate The predicate used to combine the values returned from the
+ * list of functions
+ * @param {Array} functions List of functions
+ * @return {boolean} Returns the combined result of mapping arguments to functions
+ * @example
+ *
+ * RA.argsPass(R.all, [RA.isArray, RA.isBoolean, RA.isString])([], false, 'abc') //=> true
+ * RA.argsPass(R.all, [RA.isArray, RA.isBoolean, RA.isString])([], false, 1) //=> false
+ * RA.argsPass(R.any, [RA.isArray, RA.isBoolean, RA.isString])({}, 1, 'abc') //=> true
+ * RA.argsPass(R.any, [RA.isArray, RA.isBoolean, RA.isString])({}, 1, false) //=> false
+ * RA.argsPass(R.none, [RA.isArray, RA.isBoolean, RA.isString])({}, 1, false) //=> true
+ * RA.argsPass(R.none, [RA.isArray, RA.isBoolean, RA.isString])({}, 1, 'abc') //=> false
+ */
+var argsPass = (0, _ramda.curry)(function (combiningPredicate, predicates) {
+  return (0, _ramda.useWith)((0, _ramda.compose)(combiningPredicate(_isTruthy["default"]), _list["default"]), predicates);
+});
+var _default = argsPass;
+exports["default"] = _default;

package/lib/async.js

@@ -0,0 +1,67 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _resolveP = _interopRequireDefault(require("./resolveP"));
+
+var _rejectP = _interopRequireDefault(require("./rejectP"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Takes a generator function and returns an async function.
+ * The async function returned is a curried function whose arity matches that of the generator function.
+ *
+ * Note: This function is handy for environments that does support generators but doesn't support async/await.
+ *
+ * @func async
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.16.0|v2.16.0}
+ * @category Function
+ * @sig Promise c => (a, b, ...) -> a -> b -> ... -> c
+ * @param {Function} generatorFn The generator function
+ * @return {Function} Curried async function
+ * @see {@link https://www.promisejs.org/generators/}
+ * @example
+ *
+ * const asyncFn = RA.async(function* generator(val1, val2) {
+ *   const a = yield Promise.resolve(val1);
+ *   const b = yield Promise.resolve(val2);
+ *
+ *   return a + b;
+ * });
+ *
+ * asyncFn(1, 2); //=> Promise(3)
+ *
+ */
+var async = (0, _ramda.curryN)(1, function (generatorFn) {
+  function asyncWrapper() {
+    var iterator = (0, _ramda.bind)(generatorFn, this).apply(void 0, arguments);
+
+    var handle = function handle(result) {
+      var resolved = (0, _resolveP["default"])(result.value);
+      return result.done ? resolved : resolved.then(function (value) {
+        return handle(iterator.next(value));
+      }, function (error) {
+        return handle(iterator["throw"](error));
+      });
+    };
+
+    try {
+      return handle(iterator.next());
+    } catch (error) {
+      return (0, _rejectP["default"])(error);
+    }
+  }
+
+  if (generatorFn.length > 0) {
+    return (0, _ramda.curryN)(generatorFn.length, asyncWrapper);
+  }
+
+  return asyncWrapper;
+});
+var _default = async;
+exports["default"] = _default;

package/lib/cata.js

@@ -0,0 +1,110 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * The catamorphism is a way of folding a type into a value.
+ *
+ * **Either**
+ *
+ * If the either is right then the right function will be executed with
+ * the `right` value and the value of the function returned. Otherwise the left function
+ * will be called with the `left` value.
+ *
+ * **Maybe**
+ *
+ * If the maybe is Some than the right function will be executed with the `some` value and the value of the function
+ * returned. Otherwise the left function with be called without an argument.
+ *
+ * **Result**
+ *
+ * If the result is Ok than the right function will be executed with the `Ok` value and the value of the function
+ * returned. Otherwise the left function will be called with the `Error` value.
+ *
+ * **Validation**
+ *
+ * If the validation is Success than the right function will be executed with the `Success` value and the value of the function
+ * returned. Otherwise the left function will be called with the `Failure` value.
+ *
+ * Supported monadic libraries: {@link https://monet.github.io/monet.js/|monet.js}, {@link https://folktale.origamitower.com/|folktale}, {@link https://github.com/ramda/ramda-fantasy|ramda-fantasy}
+ *
+ * @func cata
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.4.0|v1.4.0}
+ * @category Function
+ * @sig (a -> b) -> (a -> c) -> Cata a -> b | c
+ * @param {Function} leftFn The left function that consumes the left value
+ * @param {Function} rightFn The right function that consumes the right value
+ * @param {Cata} catamorphicObj Either, Maybe or any other type with catamorphic capabilities (`cata` or `either` method)
+ * @return {*}
+ * @see {@link https://monet.github.io/monet.js/#cata|cata explained}
+ * @example
+ *
+ * // Either
+ * const eitherR = Either.Right(1);
+ * const eitherL = Either.Left(2);
+ *
+ * RA.cata(identity, identity, eitherR); //=> 1
+ * RA.cata(identity, identity, eitherL); //=> 2
+ *
+ * // Maybe
+ * const maybeSome = Maybe.Some(1);
+ * const maybeNothing = Maybe.Nothing();
+ *
+ * RA.cata(identity, identity, maybeSome); //=> 1
+ * RA.cata(identity, identity, maybeNothing); //=> undefined
+ */
+var catamorphism = (0, _ramda.curry)(function (leftFn, rightFn, catamorphicObj) {
+  // folktale support
+  if ((0, _isFunction["default"])(catamorphicObj.matchWith)) {
+    return catamorphicObj.matchWith({
+      // Result type
+      Ok: function Ok(_ref) {
+        var value = _ref.value;
+        return rightFn(value);
+      },
+      Error: function Error(_ref2) {
+        var value = _ref2.value;
+        return leftFn(value);
+      },
+      // Maybe type
+      Just: function Just(_ref3) {
+        var value = _ref3.value;
+        return rightFn(value);
+      },
+      Nothing: function Nothing() {
+        return leftFn(undefined);
+      },
+      // Validation type
+      Success: function Success(_ref4) {
+        var value = _ref4.value;
+        return rightFn(value);
+      },
+      Failure: function Failure(_ref5) {
+        var value = _ref5.value;
+        return leftFn(value);
+      }
+    });
+  }
+
+  if ((0, _isFunction["default"])(catamorphicObj.cata)) {
+    return catamorphicObj.cata(leftFn, rightFn);
+  }
+
+  if ((0, _isFunction["default"])(catamorphicObj.getOrElse)) {
+    var elseValue = "RA.cata".concat(Math.random());
+    var value = catamorphicObj.getOrElse(elseValue);
+    return value === elseValue ? leftFn() : rightFn(value);
+  }
+
+  return catamorphicObj.either(leftFn, rightFn);
+});
+var _default = catamorphism;
+exports["default"] = _default;

package/lib/catchP.js

@@ -0,0 +1,30 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Composable shortcut for `Promise.catch`.
+ * The catchP function returns a Promise. It takes two arguments: a callback function for the failure of the Promise
+ * and the promise instance itself.
+ *
+ * @func catchP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.29.0|v2.29.0}
+ * @category Function
+ * @sig (a -> Promise b | b) -> Promise b
+ * @param {Function} onRejected A Function called if the Promise is rejected. This function has one argument, the rejection reason.
+ * @param {Promise} promise Any Promise
+ * @return {Promise} Returns a Promise with dealt rejected cases
+ * @see {@link RA.thenP|thenP}, {@link RA.resolveP|resolveP}, {@link RA.rejectP|rejectP}, {@link RA.allP|allP}
+ *
+ * @example
+ *
+ * RA.catchP(() => 'b', Promise.resolve('a')); //=> Promise('a')
+ * RA.catchP(() => 'b', Promise.reject('a')); //=> Promise('b')
+ */
+var catchP = (0, _ramda.invoker)(1, 'catch');
+var _default = catchP;
+exports["default"] = _default;

package/lib/ceil.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns the smallest integer greater than or equal to a given number.
+ *
+ * Note: ceil(null) returns integer 0 and does not give a NaN error.
+ *
+ * @func ceil
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.15.0|v2.15.0}
+ * @category Math
+ * @sig Number -> Number
+ * @param {number} number The number to ceil
+ * @return {number} The smallest integer greater than or equal to the given number
+ * @example
+ *
+ * RA.ceil(.95); //=> 1
+ * RA.ceil(4); //=> 4
+ * RA.ceil(7.004); //=> 8
+ * RA.ceil(-0.95); //=> -0
+ * RA.ceil(-4); //=> -4
+ * RA.ceil(-7.004); //=> -7
+ * RA.ceil(null); //=> 0
+ */
+var ceil = (0, _ramda.curryN)(1, (0, _ramda.bind)(Math.ceil, Math));
+var _default = ceil;
+exports["default"] = _default;

package/lib/compact.js

@@ -0,0 +1,30 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isFalsy = _interopRequireDefault(require("./isFalsy"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Creates an array with all falsy values removed.
+ * The values false, null, 0, "", undefined, and NaN are falsy.
+ *
+ * @func compact
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
+ * @category List
+ * @sig Filterable f => f a -> f a
+ * @param {Array} list The array to compact
+ * @return {Array} Returns the new array of filtered values
+ * @see {@link RA.isFalsy|isFalsy}
+ * @example
+ *
+ * RA.compact([0, 1, false, 2, '', 3]); //=> [1, 2, 3]
+ */
+var compact = (0, _ramda.reject)(_isFalsy["default"]);
+var _default = compact;
+exports["default"] = _default;