ramda-adjunct 2.34.0

package/lib/repeatStr.js

@@ -0,0 +1,37 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.repeatStrInvoker = exports.repeatStrPonyfill = void 0;
+
+var _ramda = require("ramda");
+
+var _String = _interopRequireDefault(require("./internal/ponyfills/String.repeat"));
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var repeatStrPonyfill = (0, _ramda.curry)(_String["default"]);
+exports.repeatStrPonyfill = repeatStrPonyfill;
+var repeatStrInvoker = (0, _ramda.flip)((0, _ramda.invoker)(1, 'repeat'));
+/**
+ * Constructs and returns a new string which contains the specified
+ * number of copies of the string on which it was called, concatenated together.
+ *
+ * @func repeatStr
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.11.0|v2.11.0}
+ * @category List
+ * @sig String -> Number -> String
+ * @param {string} value String value to be repeated
+ * @param {number} count An integer between 0 and +∞: [0, +∞), indicating the number of times to repeat the string in the newly-created string that is to be returned
+ * @return {string} A new string containing the specified number of copies of the given string
+ * @example
+ *
+ * RA.repeatStr('a', 3); //=> 'aaa'
+ */
+
+exports.repeatStrInvoker = repeatStrInvoker;
+var repeatStr = (0, _isFunction["default"])(String.prototype.repeat) ? repeatStrInvoker : repeatStrPonyfill;
+var _default = repeatStr;
+exports["default"] = _default;

package/lib/replaceAll.js

@@ -0,0 +1,42 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.replaceAllInvoker = exports.replaceAllPonyfill = void 0;
+
+var _ramda = require("ramda");
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+var _String = _interopRequireDefault(require("./internal/ponyfills/String.replaceAll"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var replaceAllPonyfill = (0, _ramda.curryN)(3, _String["default"]);
+exports.replaceAllPonyfill = replaceAllPonyfill;
+var replaceAllInvoker = (0, _ramda.invoker)(2, 'replaceAll');
+/**
+ * Replaces all substring matches in a string with a replacement.
+ *
+ * @func replaceAll
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.17.0|v2.17.0}
+ * @category String
+ * @sig String -> String -> String -> String
+ * @param {string} searchValue The substring or a global RegExp to match
+ * @param {string} replaceValue The string to replace the matches with
+ * @param {string} str The String to do the search and replacement in
+ * @return {string} A new string containing all the `searchValue` replaced with the `replaceValue`
+ * @throws {TypeError} When invalid arguments provided
+ * @see {@link http://ramdajs.com/docs/#replace|R.replace}, {@link https://github.com/tc39/proposal-string-replaceall|TC39 proposal}
+ * @example
+ *
+ * RA.replaceAll('ac', 'ef', 'ac ab ac ab'); //=> 'ef ab ef ab'
+ * RA.replaceAll('', '_', 'xxx'); //=> '_x_x_x_'
+ * RA.replaceAll(/x/g, 'v', 'xxx'); //=> 'vvv'
+ * RA.replaceAll(/x/, 'v', 'xxx'); //=> TypeError
+ */
+
+exports.replaceAllInvoker = replaceAllInvoker;
+var replaceAll = (0, _isFunction["default"])(String.prototype.replaceAll) ? replaceAllInvoker : replaceAllPonyfill;
+var _default = replaceAll;
+exports["default"] = _default;

package/lib/resolveP.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/* eslint-disable max-len */
+
+/**
+ * Composable shortcut for `Promise.resolve`.
+ *
+ * Returns a Promise object that is resolved with the given value.
+ * If the value is a thenable (i.e. has a "then" method), the returned promise will
+ * "follow" that thenable, adopting its eventual state.
+ *
+ * @func resolveP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.16.0|v1.16.0}
+ * @category Function
+ * @sig a -> Promise a
+ * @param {*} [value=undefined] Argument to be resolved by this Promise. Can also be a Promise or a thenable to resolve
+ * @return {Promise} A Promise that is resolved with the given value, or the promise passed as value, if the value was a promise object
+ * @see {@link RA.rejectP|rejectP}
+ * @example
+ *
+ * RA.resolveP(); //=> Promise(undefined)
+ * RA.resolveP('a'); //=> Promise('a')
+ * RA.resolveP([1, 2, 3]); //=> Promise([1, 2, 3])
+ */
+
+/* eslint-enable max-len */
+var resolveP = (0, _ramda.bind)(Promise.resolve, Promise);
+var _default = resolveP;
+exports["default"] = _default;

package/lib/round.js

@@ -0,0 +1,30 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns the value of a number rounded to the nearest integer.
+ *
+ * @func round
+ * @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 round
+ * @return {number} The value of the given number rounded to the nearest integer
+ * @example
+ *
+ * RA.round(0.9); //=> 1
+ * RA.round(5.95); //=> 6
+ * RA.round(5.5); //=> 6
+ * RA.round(5.05); //=> 5
+ * RA.round(-5.05); //=> -5
+ * RA.round(-5.5); //=> -5
+ * RA.round(-5.95); //=> -6
+ */
+var round = (0, _ramda.curryN)(1, (0, _ramda.bind)(Math.round, Math));
+var _default = round;
+exports["default"] = _default;

package/lib/seq.js

@@ -0,0 +1,50 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/* eslint-disable max-len */
+
+/**
+ * Runs the given list of functions in order with the supplied object, then returns the object.
+ * Also known as the normal order sequencing combinator.
+ *
+ * Acts as a transducer if a transformer is given as second parameter.
+ *
+ * @func seq
+ * @aliases sequencing
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.3.0|v2.3.0}
+ * @category Function
+ * @sig [(a -> *), (a -> *), ...] -> a -> a
+ * @param {Array} fns The list of functions to call in order with `x` whose return values will be thrown away
+ * @param {*} x
+ * @return {*} `x`
+ * @see {@link http://ramdajs.com/docs/#tap|R.tap}, {@link http://www.cs.rpi.edu/academics/courses/spring11/proglang/handouts/lambda-calculus-chapter.pdf|sequencing combinator explained}
+ * @example
+ *
+ * RA.seq([console.info, console.log])('foo'); //=> prints 'foo' via info then log
+ *
+ * // usage in composition
+ * R.pipe(
+ *   R.concat('prefix '),
+ *   RA.seq([
+ *     console.info, //=> prints 'prefix test'
+ *     console.log //=> prints 'prefix test'
+ *   ]),
+ *   R.toUpper
+ * )('test'); //=> 'PREFIX TEST'
+ */
+
+/* eslint-enable max-len */
+var seq = (0, _ramda.curry)(function (fns, x) {
+  return (0, _ramda.tap)(function (tx) {
+    return (0, _ramda.map)(function (fn) {
+      return fn(tx);
+    })(fns);
+  })(x);
+});
+var _default = seq;
+exports["default"] = _default;

package/lib/sign.js

@@ -0,0 +1,39 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.signPonyfill = void 0;
+
+var _ramda = require("ramda");
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+var _Math = _interopRequireDefault(require("./internal/ponyfills/Math.sign"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var signPonyfill = (0, _ramda.curryN)(1, _Math["default"]);
+/**
+ * Returns the sign of a number, indicating whether the number is positive, negative or zero.
+ *
+ * @func sign
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.15.0|v2.15.0}
+ * @category Math
+ * @sig Number | String -> Number
+ * @param {number} number A number
+ * @return {number} A number representing the sign of the given argument. If the argument is a positive number, negative number, positive zero or negative zero, the function will return 1, -1, 0 or -0 respectively. Otherwise, NaN is returned
+ * @example
+ *
+ * RA.sign(3); //  1
+ * RA.sign(-3); // -1
+ * RA.sign('-3'); // -1
+ * RA.sign(0); //  0
+ * RA.sign(-0); // -0
+ * RA.sign(NaN); // NaN
+ * RA.sign('foo'); // NaN
+ */
+
+exports.signPonyfill = signPonyfill;
+var sign = (0, _isFunction["default"])(Math.sign) ? (0, _ramda.curryN)(1, (0, _ramda.bind)(Math.sign, Math)) : signPonyfill;
+var _default = sign;
+exports["default"] = _default;

package/lib/skipTake.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * When given a number n and an array, returns an array containing every nth element.
+ *
+ * @func skipTake
+ * @memberOf RA
+ * @category List
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.26.0|v2.26.0}
+ * @sig Number -> [a] -> [a]
+ * @param {number} the nth element to extract
+ * @param {Array} value the input array
+ * @return {Array} An array containing every nth element
+ * @example
+ *
+ * RA.skipTake(2, [1,2,3,4]) //=> [1, 3]
+ * RA.skipTake(3, R.range(0, 20)); //=> [0, 3, 6, 9, 12, 15, 18]
+ */
+var skipTake = (0, _ramda.curry)(function (n, list) {
+  return (0, _ramda.addIndex)(_ramda.filter)((0, _ramda.pipe)((0, _ramda.nthArg)(1), (0, _ramda.modulo)(_ramda.__, n), (0, _ramda.identical)(0)))(list);
+});
+var _default = skipTake;
+exports["default"] = _default;

package/lib/sliceFrom.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns the elements of the given list or string (or object with a slice method)
+ * from fromIndex (inclusive).
+ * Dispatches to the slice method of the second argument, if present.
+ *
+ * @func sliceFrom
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.16.0|v1.16.0}
+ * @category List
+ * @sig  Number -> [a] -> [a]
+ * @param {number} fromIndex The start index (inclusive)
+ * @param {Array|string} list The list or string to slice
+ * @return {Array|string} The sliced list or string
+ * @see {@link http://ramdajs.com/docs/#slice|R.slice}, {@link RA.sliceTo|sliceTo}
+ * @example
+ *
+ * RA.sliceFrom(1, [1, 2, 3]); //=> [2, 3]
+ */
+var sliceFrom = (0, _ramda.slice)(_ramda.__, Infinity);
+var _default = sliceFrom;
+exports["default"] = _default;

package/lib/sliceTo.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns the elements of the given list or string (or object with a slice method)
+ * to toIndex (exclusive).
+ * Dispatches to the slice method of the second argument, if present.
+ *
+ * @func sliceTo
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.16.0|v1.16.0}
+ * @category List
+ * @sig  Number -> [a] -> [a]
+ * @param {number} toIndex The end index (exclusive)
+ * @param {Array|string} list The list or string to slice
+ * @return {Array|string} The sliced list or string
+ * @see {@link http://ramdajs.com/docs/#slice|R.slice}, {@link RA.sliceFrom|sliceFrom}
+ * @example
+ *
+ * RA.sliceTo(2, [1, 2, 3]); //=> [1, 2]
+ */
+var sliceTo = (0, _ramda.slice)(0);
+var _default = sliceTo;
+exports["default"] = _default;

package/lib/sortByProps.js

@@ -0,0 +1,58 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+/**
+ * Sort a list of objects by a list of props (if first prop value is equivalent, sort by second, etc).
+ *
+ * @func sortByProps
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.26.0|v2.26.0}
+ * @category List
+ * @sig [k] -> [{k: v}] -> [{k: v}]
+ * @param {Array.<string>} props A list of properties in the list param to sort by
+ * @param {Array.<object>} list A list of objects to be sorted
+ * @return {Array.<object>} A new list sorted by the properties in the props param
+ * @example
+ *
+ * sortByProps(['num'], [{num: 3}, {num: 2}, {num: 1}])
+ * //=> [{num: 1}, {num: 2} {num: 3}]
+ * sortByProps(['letter', 'num'], [{num: 3, letter: 'a'}, {num: 2, letter: 'a'} {num: 1, letter: 'z'}])
+ * //=> [ {num: 2, letter: 'a'}, {num: 3, letter: 'a'}, {num: 1, letter: 'z'}]
+ * sortByProps(['name', 'num'], [{num: 3}, {num: 2}, {num: 1}])
+ * //=> [{num: 1}, {num: 2}, {num: 3}]
+ */
+var sortByProps = (0, _ramda.curry)(function (props, list) {
+  var firstTruthy = function firstTruthy(_ref) {
+    var _ref2 = _toArray(_ref),
+        head = _ref2[0],
+        tail = _ref2.slice(1);
+
+    return (0, _ramda.reduce)(_ramda.either, head, tail);
+  };
+
+  var makeComparator = function makeComparator(propName) {
+    return (0, _ramda.comparator)(function (a, b) {
+      return (0, _ramda.lt)((0, _ramda.prop)(propName, a), (0, _ramda.prop)(propName, b));
+    });
+  };
+
+  return (0, _ramda.sort)(firstTruthy((0, _ramda.map)(makeComparator, props)), list);
+});
+var _default = sortByProps;
+exports["default"] = _default;

package/lib/spreadPath.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Spreads object under property path onto provided object.
+ * It's like {@link RA.flattenPath|flattenPath}, but removes object under the property path.
+ *
+ * @func spreadPath
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.19.0|v1.19.0}
+ * @category Object
+ * @typedef Idx = String | Int
+ * @sig [Idx] -> {k: v} -> {k: v}
+ * @param {!Array.<string|number>} path The property path to spread
+ * @param {!Object} obj The provided object
+ * @return {!Object} The result of the spread
+ * @see {@link RA.spreadProp|spreadProp}, {@link RA.flattenPath|flattenPath}
+ * @example
+ *
+ * RA.spreadPath(
+ *   ['b1', 'b2'],
+ *   { a: 1, b1: { b2: { c: 3, d: 4 } } }
+ * ); // => { a: 1, c: 3, d: 4, b1: {} };
+ */
+var spreadPath = (0, _ramda.curryN)(2, (0, _ramda.converge)(_ramda.merge, [_ramda.dissocPath, (0, _ramda.pathOr)({})]));
+var _default = spreadPath;
+exports["default"] = _default;

package/lib/spreadProp.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _spreadPath = _interopRequireDefault(require("./spreadPath"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Spreads object under property onto provided object.
+ * It's like {@link RA.flattenProp|flattenProp}, but removes object under the property.
+ *
+ * @func spreadProp
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.19.0|v1.19.0}
+ * @category Object
+ * @typedef Idx = String | Int
+ * @sig Idx -> {k: v} -> {k: v}
+ * @param {!string|number} prop The property to spread
+ * @param {!Object} obj The provided object
+ * @return {!Object} The result of the spread
+ * @see {@link RA.spreadPath|spreadPath}, {@link RA.flattenProp|flattenProp}
+ * @example
+ *
+ * RA.spreadProp('b', { a: 1, b: { c: 3, d: 4 } }); // => { a: 1, c: 3, d: 4 };
+ */
+var spreadProp = (0, _ramda.curry)(function (prop, obj) {
+  return (0, _spreadPath["default"])((0, _ramda.of)(prop), obj);
+});
+var _default = spreadProp;
+exports["default"] = _default;

package/lib/stubArray.js

@@ -0,0 +1,25 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+/**
+ * A function that returns new empty array on every call.
+ *
+ * @func stubArray
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.1.0|v2.1.0}
+ * @category Function
+ * @sig ... -> Array
+ * @return {Array} New empty array
+ * @example
+ *
+ * RA.stubArray(); //=> []
+ * RA.stubArray(1, 2, 3); //=> []
+ */
+var stubArray = function stubArray() {
+  return [];
+};
+
+var _default = stubArray;
+exports["default"] = _default;

package/lib/stubNull.js

@@ -0,0 +1,24 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * A function that returns `null`.
+ *
+ * @func stubNull
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.6.0|v1.6.0}
+ * @category Function
+ * @sig ... -> null
+ * @return {null}
+ * @example
+ *
+ * RA.stubNull(); //=> null
+ * RA.stubNull(1, 2, 3); //=> null
+ */
+var stubNull = (0, _ramda.always)(null);
+var _default = stubNull;
+exports["default"] = _default;

package/lib/stubObj.js

@@ -0,0 +1,26 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+/**
+ * This function returns a new empty object.
+ *
+ * @func stubObj
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.1.0|v2.1.0}
+ * @category Function
+ * @sig ... -> Object
+ * @aliases stubObject
+ * @return {Object} Returns the new empty object.
+ * @example
+ *
+ * RA.stubObj(); //=> {}
+ * RA.stubObj(1, 2, 3); //=> {}
+ */
+var stubObj = function stubObj() {
+  return {};
+};
+
+var _default = stubObj;
+exports["default"] = _default;

package/lib/stubString.js

@@ -0,0 +1,24 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * A function that returns empty string.
+ *
+ * @func stubString
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.1.0|v2.1.0}
+ * @category Function
+ * @sig ... -> String
+ * @return {string} The empty string
+ * @example
+ *
+ * RA.stubString(); //=> ''
+ * RA.stubString(1, 2, 3); //=> ''
+ */
+var stubString = (0, _ramda.always)('');
+var _default = stubString;
+exports["default"] = _default;

package/lib/stubUndefined.js

@@ -0,0 +1,25 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * A function that returns `undefined`.
+ *
+ * @func stubUndefined
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.0.0|v1.0.0}
+ * @category Function
+ * @sig ... -> undefined
+ * @return {undefined}
+ * @example
+ *
+ * RA.stubUndefined(); //=> undefined
+ * RA.stubUndefined(1, 2, 3); //=> undefined
+ */
+var stubUndefined = (0, _ramda.always)(void 0); // eslint-disable-line no-void
+
+var _default = stubUndefined;
+exports["default"] = _default;

package/lib/subtractNum.js

@@ -0,0 +1,25 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Subtracts its first argument from its second argument.
+ *
+ * @func subtractNum
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category Math
+ * @sig Number -> Number -> Number
+ * @param {number} subtrahend the number to subtract
+ * @param {number} minuend the number to subtract from
+ * @return {number} A number representing the difference of subtracting the subtrahend from the minuend
+ * @example
+ *
+ * RA.subtractNum(3, 5); //=> 2
+ */
+var subtractNum = (0, _ramda.flip)(_ramda.subtract);
+var _default = subtractNum;
+exports["default"] = _default;

package/lib/thenCatchP.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.thenCatchP = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Composable shortcut for `Promise.then` that allows for success and failure callbacks.
+ * The thenCatchP function returns a Promise. It takes three arguments: a callback function for the success of the Promise,
+ * a callback function for the failure of the Promise, and the promise instance itself.
+ *
+ * @func thenCatchP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.27.0|v2.27.0}
+ * @category Function
+ * @sig (a -> b) -> (c -> d) -> Promise a -> Promise b | d
+ * @param {Function} onFulfilled A Function called if the Promise is fulfilled. This function has one argument, the fulfillment value
+ * @param {Function} onRejected A Function called if the Promise is rejected. This function has one argument, the error
+ * @param {Promise} promise Any Promise or Thenable object
+ * @return {Promise}
+ * @see {@link RA.resolveP|resolveP}, {@link RA.rejectP|rejectP}, {@link RA.allP|allP}
+ * @example
+ *
+ * const promise = Promise.resolve(1);
+ * const add1 = x => x + 1;
+ *
+ * RA.thenCatchP(add1, console.error, promise); // => Promise(2)
+ */
+var thenCatchP = (0, _ramda.invoker)(2, 'then');
+exports.thenCatchP = thenCatchP;
+var _default = thenCatchP;
+exports["default"] = _default;

package/lib/thenP.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Composable shortcut for `Promise.then`.
+ * The thenP function returns a Promise. It takes two arguments: a callback function for the success of the Promise
+ * and the promise instance itself.
+ *
+ * @func thenP
+ * @memberOf RA
+ * @aliases then
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
+ * @deprecated since v2.12.0; available in ramda@0.26.0 as R.then
+ * @category Function
+ * @sig (a -> Promise b | b) -> Promise b
+ * @param {Function} onFulfilled A Function called if the Promise is fulfilled. This function has one argument, the fulfillment value
+ * @param {Promise} promise Any Promise or Thenable object
+ * @return {Promise} A Promise in the pending status
+
+ * @see {@link RA.resolveP|resolveP}, {@link RA.rejectP|rejectP}, {@link RA.allP|allP}
+ * @example
+ *
+ * const promise = Promise.resolve(1);
+ * const add1 = v => v + 1;
+ *
+ * RA.thenP(add1, promise); // => Promise(2)
+ */
+var thenP = (0, _ramda.invoker)(1, 'then');
+var _default = thenP;
+exports["default"] = _default;