ramda-adjunct 2.34.0

package/lib/pathNotEq.js

@@ -0,0 +1,38 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/* eslint-disable max-len */
+
+/**
+ * Determines whether a nested path on an object doesn't have a specific value,
+ * in R.equals terms. Most likely used to filter a list.
+ *
+ * @func pathNotEq
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.4.0|v2.4.0}
+ * @category Relation
+ * @sig [Idx] => a => {a} => Boolean
+ * @sig Idx = String | Int
+ * @param {Array} path The path of the nested property to use
+ * @param {a} val The value to compare the nested property with
+ * @param {Object} object The object to check the nested property in
+ * @return {boolean} Returns Boolean `false` if the value equals the nested object property, `true` otherwise
+ * @see {@link http://ramdajs.com/docs/#pathEq|R.pathEq}
+ * @example
+ *
+ * const user1 = { address: { zipCode: 90210 } };
+ * const user2 = { address: { zipCode: 55555 } };
+ * const user3 = { name: 'Bob' };
+ * const users = [ user1, user2, user3 ];
+ * const isFamous = R.pathNotEq(['address', 'zipCode'], 90210);
+ * R.filter(isFamous, users); //=> [ user2, user3 ]
+ */
+
+/* eslint-enable max-len */
+var pathNotEq = (0, _ramda.complement)(_ramda.pathEq);
+var _default = pathNotEq;
+exports["default"] = _default;

package/lib/pathOrLazy.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * If the given, non-null object has a value at the given path, returns the value at that path.
+ * Otherwise returns the result of invoking the provided function with the object.
+ *
+ * @func pathOrLazy
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category Object
+ * @typedef Idx = String | Int
+ * @sig ({a} -> a) -> [Idx] -> {a} -> a
+ * @param {Function} defaultFn The function that will return the default value.
+ * @param {Array} path The path to use.
+ * @param {Object} obj The object to retrieve the nested property from.
+ * @return {*} The data at `path` of the supplied object or the default value.
+ * @example
+ *
+ * RA.pathOrLazy(() => 'N/A', ['a', 'b'], {a: {b: 2}}); //=> 2
+ * RA.pathOrLazy(() => 'N/A', ['a', 'b'], {c: {b: 2}}); //=> "N/A"
+ */
+var pathOrLazy = (0, _ramda.curryN)(3, function (defaultFn, path, obj) {
+  return (0, _ramda.when)((0, _ramda.identical)(defaultFn), (0, _ramda.partial)((0, _ramda.unary)(defaultFn), [obj]), (0, _ramda.pathOr)(defaultFn, path, obj));
+});
+var _default = pathOrLazy;
+exports["default"] = _default;

package/lib/paths.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Acts as multiple path: arrays of paths in, array of values out. Preserves order.
+ *
+ * @func paths
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.2.0|v1.2.0}
+ * @category List
+ * @sig  [[k]] -> {k: v} - [v]
+ * @param {Array} ps The property paths to fetch
+ * @param {Object} obj The object to query
+ * @return {Array} The corresponding values or partially applied function
+ * @see {@link https://github.com/ramda/ramda/wiki/Cookbook#derivative-of-rprops-for-deep-fields|Ramda Cookbook}, {@link http://ramdajs.com/docs/#props|R.props}
+ * @example
+ *
+ * const obj = {
+ *   a: { b: { c: 1 } },
+ *   x: 2,
+ * };
+ *
+ * RA.paths([['a', 'b', 'c'], ['x']], obj); //=> [1, 2]
+ */
+var paths = (0, _ramda.curry)(function (ps, obj) {
+  return (0, _ramda.ap)([(0, _ramda.path)(_ramda.__, obj)], ps);
+});
+var _default = paths;
+exports["default"] = _default;

package/lib/pickIndexes.js

@@ -0,0 +1,37 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+// helpers
+var filterIndexed = (0, _ramda.addIndex)(_ramda.filter);
+var containsIndex = (0, _ramda.curry)(function (indexes, val, index) {
+  return (0, _ramda.contains)(index, indexes);
+});
+/**
+ * Picks values from list by indexes.
+ *
+ * Note: pickIndexes will skip non existing indexes. If you want to include them
+ * use ramda's `props` function.
+ *
+ * @func pickIndexes
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.1.0|v1.1.0}
+ * @category List
+ * @sig  [Number] -> [a] -> [a]
+ * @param {Array} indexes The indexes to pick
+ * @param {Array} list The list to pick values from
+ * @return {Array} New array containing only values at `indexes`
+ * @see {@link http://ramdajs.com/docs/#pick|R.pick}, {@link RA.omitIndexes|omitIndexes}
+ * @example
+ *
+ * RA.pickIndexes([0, 2], ['a', 'b', 'c']); //=> ['a', 'c']
+ */
+
+var pickIndexes = (0, _ramda.curry)(function (indexes, list) {
+  return filterIndexed(containsIndex(indexes), list);
+});
+var _default = pickIndexes;
+exports["default"] = _default;

package/lib/propNotEq.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns true if the specified object property is not equal,
+ * in R.equals terms, to the given value; false otherwise.
+ *
+ * @func propNotEq
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.3.0|v2.3.0}
+ * @category Relation
+ * @sig  String -> a -> Object -> Boolean
+ * @param {String} name The property to pick
+ * @param {a} val The value to compare to
+ * @param {Object} object The object, that presumably contains value under the property
+ * @return {boolean} Comparison result
+ * @see {@link http://ramdajs.com/docs/#propEq|R.propEq}
+ * @example
+ *
+ * const abby = { name: 'Abby', age: 7, hair: 'blond' };
+ * const fred = { name: 'Fred', age: 12, hair: 'brown' };
+ * const rusty = { name: 'Rusty', age: 10, hair: 'brown' };
+ * const alois = { name: 'Alois', age: 15, disposition: 'surly' };
+ * const kids = [abby, fred, rusty, alois];
+ * const hasNotBrownHair = RA.propNotEq('hair', 'brown');
+ *
+ * R.filter(hasNotBrownHair, kids); //=> [abby, alois]
+ */
+var propNotEq = (0, _ramda.complement)(_ramda.propEq);
+var _default = propNotEq;
+exports["default"] = _default;

package/lib/rangeStep.js

@@ -0,0 +1,45 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _floor = _interopRequireDefault(require("./floor"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Creates an array of numbers (positive and/or negative) progressing from start up to, but not including, end.
+ *
+ * `Note`: JavaScript follows the IEEE-754 standard for resolving floating-point values which can produce unexpected results.
+ *
+ * @func rangeStep
+ * @memberOf RA
+ * @category List
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.30.0|v2.30.0}
+ * @sig Number -> Number -> Number -> [Number]
+ * @param {number} step The value to increment or decrement by
+ * @param {number} from The start of the range
+ * @param {number} to The end of the range
+ * @return {number[]} Returns the range of numbers
+ * @see {@link http://ramdajs.com/docs/#range|R.range}
+ * @example
+ *
+ * RA.rangeStep(1, 0, 4); // => [0, 1 ,2, 3]
+ * RA.rangeStep(-1, 0, -4); // => [0, -1, -2, -3]
+ * RA.rangeStep(1, 1, 5); // => [1, 2, 3, 4]
+ * RA.rangeStep(5, 0, 20); // => [0, 5, 10, 15]
+ * RA.rangeStep(-1, 0, -4); // => [0, -1, -2, -3]
+ * RA.rangeStep(0, 1, 4); // => [1, 1, 1]
+ * RA.rangeStep(1, 0, 0); // => []
+ */
+var rangeStep = (0, _ramda.curryN)(3, function (step, from, to) {
+  var callback = step === 0 ? (0, _ramda.always)(from) : function (n) {
+    return from + step * n;
+  };
+  var rangeEnd = step === 0 ? to - from : (0, _floor["default"])((to - from) / step);
+  return (0, _ramda.map)(callback, (0, _ramda.range)(0, rangeEnd));
+});
+var _default = rangeStep;
+exports["default"] = _default;

package/lib/reduceIndexed.js

@@ -0,0 +1,36 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * {@link http://ramdajs.com/docs/#reduce|R.reduce} function that more closely resembles Array.prototype.reduce.
+ * It takes two new parameters to its callback function: the current index, and the entire list.
+ *
+ * `reduceIndexed` implementation is simple : `
+ * const reduceIndexed = R.addIndex(R.reduce);
+ * `
+ * @func reduceIndexed
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
+ * @category List
+ * @typedef Idx = Number
+ * @sig ((a, b, Idx, [b]) => a) -> a -> [b] -> a
+ * @param {Function} fn The iterator function. Receives four values,
+ * the accumulator, the current element from the array, index and the entire list
+ * @param {*} acc The accumulator value
+ * @param {Array} list The list to iterate over
+ * @return {*} The final, accumulated value
+ * @see {@link http://ramdajs.com/docs/#addIndex|R.addIndex}, {@link http://ramdajs.com/docs/#reduce|R.reduce}
+ * @example
+ *
+ * const initialList = ['f', 'o', 'o', 'b', 'a', 'r'];
+ *
+ * reduceIndexed((acc, val, idx, list) => acc + '-' + val + idx, '', initialList);
+ * //=> "-f0-o1-o2-b3-a4-r5"
+ */
+var reduceIndexed = (0, _ramda.addIndex)(_ramda.reduce);
+var _default = reduceIndexed;
+exports["default"] = _default;

package/lib/reduceP.js

@@ -0,0 +1,122 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isUndefined = _interopRequireDefault(require("./isUndefined"));
+
+var _resolveP = _interopRequireDefault(require("./resolveP"));
+
+var _allP = _interopRequireDefault(require("./allP"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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 _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+/* eslint-disable max-len */
+
+/**
+ * Given an `Iterable`(arrays are `Iterable`), or a promise of an `Iterable`,
+ * which produces promises (or a mix of promises and values),
+ * iterate over all the values in the `Iterable` into an array and
+ * reduce the array to a value using the given iterator function.
+ *
+ * If the iterator function returns a promise, then the result of the promise is awaited,
+ * before continuing with next iteration. If any promise in the array is rejected or a promise
+ * returned by the iterator function is rejected, the result is rejected as well.
+ *
+ * If `initialValue` is `undefined` (or a promise that resolves to `undefined`) and
+ * the `Iterable` contains only 1 item, the callback will not be called and
+ * the `Iterable's` single item is returned. If the `Iterable` is empty, the callback
+ * will not be called and `initialValue` is returned (which may be undefined).
+ *
+ * This function is basically equivalent to {@link http://bluebirdjs.com/docs/api/promise.reduce.html|bluebird.reduce}.
+ *
+ * @func reduceP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|v1.13.0}
+ * @category List
+ * @typedef MaybePromise = Promise.<*> | *
+ * @sig ((Promise a, MaybePromise b) -> Promise a) -> MaybePromise a -> MaybePromise [MaybePromise b] -> Promise a
+ * @param {Function} fn The iterator function. Receives two values, the accumulator and the current element from the list
+ * @param {*|Promise.<*>} acc The accumulator value
+ * @param {Array.<*>|Promise.<Array<*|Promise.<*>>>} list The list to iterate over
+ * @return {Promise} The final, accumulated value
+ * @see {@link http://ramdajs.com/docs/#reduce|R.reduce}, {@link RA.reduceRightP|reduceRightP}, {@link http://bluebirdjs.com/docs/api/promise.reduce.html|bluebird.reduce}
+ * @example
+ *
+ * RA.reduceP(
+ *   (total, fileName) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   0,
+ *   ['file1.txt', 'file2.txt', 'file3.txt']
+ * ); // => Promise(10)
+ *
+ * RA.reduceP(
+ *   (total, fileName) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   Promise.resolve(0),
+ *   ['file1.txt', 'file2.txt', 'file3.txt']
+ * ); // => Promise(10)
+ *
+ * RA.reduceP(
+ *   (total, fileName) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   0,
+ *   [Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt']
+ * ); // => Promise(10)
+ *
+ * RA.reduceP(
+ *   (total, fileName) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   0,
+ *   Promise.resolve([Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt'])
+ * ); // => Promise(10)
+ *
+ */
+
+/* esline-enable max-len */
+var reduceP = (0, _ramda.curryN)(3, function (fn, acc, list) {
+  return (0, _resolveP["default"])(list).then(function (iterable) {
+    var listLength = (0, _ramda.length)(iterable);
+
+    if (listLength === 0) {
+      return acc;
+    }
+
+    var reducer = (0, _ramda.reduce)(function (accP, currentValueP) {
+      return accP.then(function (previousValue) {
+        return (0, _allP["default"])([previousValue, currentValueP]);
+      }).then(function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 2),
+            previousValue = _ref2[0],
+            currentValue = _ref2[1];
+
+        if ((0, _isUndefined["default"])(previousValue) && listLength === 1) {
+          return currentValue;
+        }
+
+        return fn(previousValue, currentValue);
+      });
+    });
+    return reducer((0, _resolveP["default"])(acc), iterable);
+  });
+});
+var _default = reduceP;
+exports["default"] = _default;

package/lib/reduceRightP.js

@@ -0,0 +1,129 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isUndefined = _interopRequireDefault(require("./isUndefined"));
+
+var _resolveP = _interopRequireDefault(require("./resolveP"));
+
+var _allP = _interopRequireDefault(require("./allP"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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 _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+// in older ramda versions the order of the arguments is flipped
+var flipArgs = (0, _ramda.pipe)((0, _ramda.reduceRight)(_ramda.concat, ''), (0, _ramda.equals)('ba'))(['a', 'b']);
+/* eslint-disable max-len */
+
+/**
+ * Given an `Iterable`(arrays are `Iterable`), or a promise of an `Iterable`,
+ * which produces promises (or a mix of promises and values),
+ * iterate over all the values in the `Iterable` into an array and
+ * reduce the array to a value using the given iterator function.
+ *
+ * Similar to {@link RA.reduceP|reduceP} except moves through the input list from the right to the left.
+ * The iterator function receives two values: (value, acc),
+ * while the arguments' order of reduceP's iterator function is (acc, value).
+ *
+ * @func reduceRightP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|v1.13.0}
+ * @category List
+ * @typedef MaybePromise = Promise.<*> | *
+ * @sig ((MaybePromise b, Promise a) -> Promise a) -> MaybePromise a -> MaybePromise [MaybePromise b] -> Promise a
+ * @param {Function} fn The iterator function. Receives two values, the current element from the list and the accumulator
+ * @param {*|Promise.<*>} acc The accumulator value
+ * @param {Array.<*>|Promise.<Array<*|Promise.<*>>>} list The list to iterate over
+ * @return {Promise} The final, accumulated value
+ * @see {@link RA.reduceP|reduceP}, {@link http://bluebirdjs.com/docs/api/promise.reduce.html|bluebird.reduce}
+ * @example
+ *
+ * RA.reduceRightP(
+ *   (fileName, total) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   0,
+ *   ['file1.txt', 'file2.txt', 'file3.txt']
+ * ); // => Promise(10)
+ *
+ * RA.reduceRightP(
+ *   (fileName, total) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   Promise.resolve(0),
+ *   ['file1.txt', 'file2.txt', 'file3.txt']
+ * ); // => Promise(10)
+ *
+ * RA.reduceRightP(
+ *   (fileName, total) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   0,
+ *   [Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt']
+ * ); // => Promise(10)
+ *
+ * RA.reduceRightP(
+ *   (fileName, total) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   0,
+ *   Promise.resolve([Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt'])
+ * ); // => Promise(10)
+ *
+ */
+
+/* esline-enable max-len */
+
+var reduceRightP = (0, _ramda.curryN)(3, function (fn, acc, list) {
+  return (0, _resolveP["default"])(list).then(function (iterable) {
+    var listLength = (0, _ramda.length)(iterable);
+
+    if (listLength === 0) {
+      return acc;
+    }
+
+    var reducer = (0, _ramda.reduceRight)(function (arg1, arg2) {
+      var accP;
+      var currentValueP;
+
+      if (flipArgs) {
+        accP = arg1;
+        currentValueP = arg2;
+      } else {
+        accP = arg2;
+        currentValueP = arg1;
+      }
+
+      return accP.then(function (previousValue) {
+        return (0, _allP["default"])([previousValue, currentValueP]);
+      }).then(function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 2),
+            previousValue = _ref2[0],
+            currentValue = _ref2[1];
+
+        if ((0, _isUndefined["default"])(previousValue) && listLength === 1) {
+          return currentValue;
+        }
+
+        return fn(currentValue, previousValue);
+      });
+    });
+    return reducer((0, _resolveP["default"])(acc), iterable);
+  });
+});
+var _default = reduceRightP;
+exports["default"] = _default;

package/lib/rejectP.js

@@ -0,0 +1,29 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Composable shortcut for `Promise.reject`.
+ *
+ * Returns a Promise object that is rejected with the given reason.
+ *
+ * @func rejectP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.16.0|v1.16.0}
+ * @category Function
+ * @sig a -> Promise a
+ * @param {*} [reason=undefined] Reason why this Promise rejected
+ * @return {Promise} A Promise that is rejected with the given reason
+ * @see {@link RA.resolveP|resolveP}
+ * @example
+ *
+ * RA.rejectP(); //=> Promise(undefined)
+ * RA.rejectP('a'); //=> Promise('a')
+ * RA.rejectP([1, 2, 3]); //=> Promise([1, 2, 3])
+ */
+var rejectP = (0, _ramda.bind)(Promise.reject, Promise);
+var _default = rejectP;
+exports["default"] = _default;

package/lib/renameKeyWith.js

@@ -0,0 +1,37 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _renameKeysWith = _interopRequireDefault(require("./renameKeysWith"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Creates a new object with the own properties of the provided object, but the
+ * key `key` renamed according to logic of renaming function.
+ *
+ * Keep in mind that in case the new key name already existed on the object,
+ * the behaviour is undefined and the result may vary between various JS engines!
+ *
+ * @func renameKeyWith
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.29.0|v2.29.0}
+ * @category Object
+ * @sig (k -> k) -> k -> {k: v} -> {k: v}
+ * @param {Function} fn Function that renames the keys
+ * @param {!string} key Key to rename
+ * @param {!Object} obj Provided object
+ * @return {!Object} New object with renamed key
+ * @see {@link RA.renameKeysWith|renameKeysWith}
+ * @example
+ *
+ * RA.renameKeyWith(R.concat('a'), 'A', { A: 1 }) //=> { aA: 1 }
+ */
+var renameKeyWith = (0, _ramda.curry)(function (fn, key, obj) {
+  return (0, _renameKeysWith["default"])((0, _ramda.when)((0, _ramda.equals)(key), fn), obj);
+});
+var _default = renameKeyWith;
+exports["default"] = _default;

package/lib/renameKeys.js

@@ -0,0 +1,51 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _renameKeysWith = _interopRequireDefault(require("./renameKeysWith"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var valueOrKey = function valueOrKey(keysMap) {
+  return function (key) {
+    if ((0, _ramda.has)(key, keysMap)) {
+      return keysMap[key];
+    }
+
+    return key;
+  };
+};
+/**
+ * Creates a new object with the own properties of the provided object, but the
+ * keys renamed according to the keysMap object as `{oldKey: newKey}`.
+ * When some key is not found in the keysMap, then it's passed as-is.
+ *
+ * Keep in mind that in the case of keys conflict is behaviour undefined and
+ * the result may vary between various JS engines!
+ *
+ * @func renameKeys
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.5.0|v1.5.0}
+ * @category Object
+ * @sig {a: b} -> {a: *} -> {b: *}
+ * @param {!Object} keysMap
+ * @param {!Object} obj
+ * @return {!Object} New object with renamed keys
+ * @see {@link https://github.com/ramda/ramda/wiki/Cookbook#rename-keys-of-an-object|Ramda Cookbook}, {@link RA.renameKeysWith|renameKeysWith}
+ * @example
+ *
+ * const input = { firstName: 'Elisia', age: 22, type: 'human' };
+ *
+ * RA.renameKeys({ firstName: 'name', type: 'kind', foo: 'bar' })(input);
+ * //=> { name: 'Elisia', age: 22, kind: 'human' }
+ */
+
+
+var renameKeys = (0, _ramda.curry)(function (keysMap, obj) {
+  return (0, _renameKeysWith["default"])(valueOrKey(keysMap), obj);
+});
+var _default = renameKeys;
+exports["default"] = _default;

package/lib/renameKeysWith.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Creates a new object with the own properties of the provided object, but the
+ * keys renamed according to logic of renaming function.
+ *
+ * Keep in mind that in the case of keys conflict is behaviour undefined and
+ * the result may vary between various JS engines!
+ *
+ * @func renameKeysWith
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.5.0|v1.5.0}
+ * @category Object
+ * @sig (a -> b) -> {a: *} -> {b: *}
+ * @param {Function} fn Function that renames the keys
+ * @param {!Object} obj Provided object
+ * @return {!Object} New object with renamed keys
+ * @see {@link https://github.com/ramda/ramda/wiki/Cookbook#rename-keys-of-an-object-by-a-function|Ramda Cookbook}, {@link RA.renameKeys|renameKeys}
+ * @example
+ *
+ * RA.renameKeysWith(R.concat('a'), { A: 1, B: 2, C: 3 }) //=> { aA: 1, aB: 2, aC: 3 }
+ */
+var renameKeysWith = (0, _ramda.curry)(function (fn, obj) {
+  return (0, _ramda.pipe)(_ramda.toPairs, (0, _ramda.map)((0, _ramda.over)((0, _ramda.lensIndex)(0), fn)), _ramda.fromPairs)(obj);
+});
+var _default = renameKeysWith;
+exports["default"] = _default;