ramda-adjunct 2.34.0

package/lib/lengthLte.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _compareLength = _interopRequireDefault(require("./internal/compareLength"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Returns `true` if the supplied list or string has a length less than or equal to `valueLength`.
+ *
+ * @func lengthLte
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
+ * @category List
+ * @sig Number -> [*] -> Boolean
+ * @param {number} valueLength The length of the list or string
+ * @param {Array|string} value The list or string
+ * @return {boolean}
+ * @see {@link RA.lengthEq|lengthEq}, {@link RA.lengthNotEq|lengthNotEq}, {@link RA.lengthLt|lengthLt}, {@link RA.lengthGt|lengthGt}, {@link RA.lengthGte|lengthGte}, {@link http://ramdajs.com/docs/#lte|lte}, {@link http://ramdajs.com/docs/#length|length}
+ * @example
+ *
+ * RA.lengthLte(3, [1,2]); //=> true
+ * RA.lengthLte(3, [1,2,3]); //=> true
+ * RA.lengthLte(3, [1,2,3,4]); //=> false
+ */
+var lengthLte = (0, _compareLength["default"])((0, _ramda.flip)(_ramda.lte));
+var _default = lengthLte;
+exports["default"] = _default;

package/lib/lengthNotEq.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _compareLength = _interopRequireDefault(require("./internal/compareLength"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Returns `true` if the supplied list or string has a length not equal to `valueLength`.
+ *
+ * @func lengthNotEq
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
+ * @category List
+ * @sig Number -> [*] -> Boolean
+ * @param {number} valueLength The length of the list or string
+ * @param {Array|string} value The list or string
+ * @return {boolean}
+ * @see {@link RA.lengthEq|lengthEq}, {@link RA.lengthLt|lengthLt}, {@link RA.lengthGt|lengthGt}, {@link RA.lengthLte|lengthLte}, {@link RA.lengthGte|lengthGte}, {@link http://ramdajs.com/docs/#equals|equals}, {@link http://ramdajs.com/docs/#length|length}
+ * @example
+ *
+ * RA.lengthNotEq(3, [1,2,3,4]); //=> true
+ * RA.lengthNotEq(3, [1,2,3]); //=> false
+ */
+var lengthNotEq = (0, _compareLength["default"])((0, _ramda.complement)(_ramda.equals));
+var _default = lengthNotEq;
+exports["default"] = _default;

package/lib/lensEq.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns `true` if data structure focused by the given lens equals provided value.
+ *
+ * @func lensEq
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|1.13.0}
+ * @category Relation
+ * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s
+ * @sig  Lens s a -> b -> s -> Boolean
+ * @see {@link RA.lensNotEq|lensNotEq}
+ * @param {function} lens Van Laarhoven lens
+ * @param {*} value The value to compare the focused data structure with
+ * @param {*} data The data structure
+ * @return {boolean} `true` if the focused data structure equals value, `false` otherwise
+ *
+ * @example
+ *
+ * RA.lensEq(R.lensIndex(0), 1, [0, 1, 2]); // => false
+ * RA.lensEq(R.lensIndex(1), 1, [0, 1, 2]); // => true
+ * RA.lensEq(R.lensPath(['a', 'b']), 'foo', { a: { b: 'foo' } }) // => true
+ */
+var lensEq = (0, _ramda.curryN)(3, function (lens, val, data) {
+  return (0, _ramda.pipe)((0, _ramda.view)(lens), (0, _ramda.equals)(val))(data);
+});
+var _default = lensEq;
+exports["default"] = _default;

package/lib/lensIso.js

@@ -0,0 +1,62 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+// This implementation was highly inspired by the implementations
+// in ramda-lens library.
+//
+// https://github.com/ramda/ramda-lens
+// isomorphic :: ((a -> b), (b -> a)) -> Isomorphism
+//     Isomorphism = x -> y
+var isomorphic = function isomorphic(to, from) {
+  var isomorphism = function isomorphism(x) {
+    return to(x);
+  };
+
+  isomorphism.from = from;
+  return isomorphism;
+}; // isomorphisms :: ((a -> b), (b -> a)) -> (a -> b)
+
+
+var isomorphisms = function isomorphisms(to, from) {
+  return isomorphic((0, _ramda.curry)(function (toFunctorFn, target) {
+    return (0, _ramda.map)(from, toFunctorFn(to(target)));
+  }), (0, _ramda.curry)(function (toFunctorFn, target) {
+    return (0, _ramda.map)(to, toFunctorFn(from(target)));
+  }));
+}; // from :: Isomorphism -> a -> b
+
+
+var from = (0, _ramda.curry)(function (isomorphism, x) {
+  return isomorphism.from(x);
+});
+/**
+ * Defines an isomorphism that will work like a lens. It takes two functions.
+ * The function that converts and the function that recovers.
+ *
+ * @func lensIso
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.19.0|1.19.0}
+ * @category Relation
+ * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s
+ * @sig (s -> a) -> (a -> s) -> Lens s a
+ * @param {!function} to The function that converts
+ * @param {!function} from The function that recovers
+ * @return {!function} The isomorphic lens
+ * @see {@link http://ramdajs.com/docs/#lens|R.lens}
+ *
+ * @example
+ *
+ * const lensJSON = RA.lensIso(JSON.parse, JSON.stringify);
+ *
+ * R.over(lensJSON, assoc('b', 2), '{"a":1}'); //=> '{"a":1,"b":2}'
+ * R.over(RA.lensIso.from(lensJSON), R.replace('}', ',"b":2}'), { a: 1 }); // => { a: 1, b: 2 }
+ */
+
+var lensIso = (0, _ramda.curry)(isomorphisms);
+lensIso.from = from;
+var _default = lensIso;
+exports["default"] = _default;

package/lib/lensNotEq.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _lensEq = _interopRequireDefault(require("./lensEq"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Returns `true` if data structure focused by the given lens doesn't equal provided value.
+ *
+ * @func lensNotEq
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|1.13.0}
+ * @category Relation
+ * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s
+ * @sig Lens s a -> b -> s -> Boolean
+ * @see {@link RA.lensEq|lensEq}
+ * @param {function} lens Van Laarhoven lens
+ * @param {*} value The value to compare the focused data structure with
+ * @param {*} data The data structure
+ * @return {boolean} `false` if the focused data structure equals value, `true` otherwise
+ *
+ * @example
+ *
+ * RA.lensNotEq(R.lensIndex(0), 1, [0, 1, 2]); // => true
+ * RA.lensNotEq(R.lensIndex(1), 1, [0, 1, 2]); // => false
+ * RA.lensNotEq(R.lensPath(['a', 'b']), 'foo', { a: { b: 'foo' } }) // => false
+ */
+var lensNotEq = (0, _ramda.complement)(_lensEq["default"]);
+var _default = lensNotEq;
+exports["default"] = _default;

package/lib/lensNotSatisfy.js

@@ -0,0 +1,37 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _lensSatisfies = _interopRequireDefault(require("./lensSatisfies"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Returns `true` if data structure focused by the given lens doesn't satisfy the predicate.
+ * Note that the predicate is expected to return boolean value.
+ *
+ * @func lensNotSatisfy
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|1.13.0}
+ * @category Relation
+ * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s
+ * @sig  Boolean b => (a -> b) -> Lens s a -> s -> b
+ * @see {@link RA.lensSatisfies|lensSatisfies}
+ * @param {Function} predicate The predicate function
+ * @param {Function} lens Van Laarhoven lens
+ * @param {*} data The data structure
+ * @return {boolean} `false` if the focused data structure satisfies the predicate, `true` otherwise
+ *
+ * @example
+ *
+ * RA.lensNotSatisfy(RA.isTrue, R.lensIndex(0), [false, true, 1]); // => true
+ * RA.lensNotSatisfy(RA.isTrue, R.lensIndex(1), [false, true, 1]); // => false
+ * RA.lensNotSatisfy(RA.isTrue, R.lensIndex(2), [false, true, 1]); // => true
+ * RA.lensNotSatisfy(R.identity, R.lensProp('x'), { x: 1 }); // => true
+ */
+var lensNotSatisfy = (0, _ramda.complement)(_lensSatisfies["default"]);
+var _default = lensNotSatisfy;
+exports["default"] = _default;

package/lib/lensSatisfies.js

@@ -0,0 +1,40 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isTrue = _interopRequireDefault(require("./isTrue"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Returns `true` if data structure focused by the given lens satisfies the predicate.
+ * Note that the predicate is expected to return boolean value and will be evaluated
+ * as `false` unless the predicate returns `true`.
+ *
+ * @func lensSatisfies
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|1.13.0}
+ * @category Relation
+ * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s
+ * @sig  Boolean b => (a -> b) -> Lens s a -> s -> b
+ * @see {@link RA.lensNotSatisfy|lensNotSatisfy}
+ * @param {Function} predicate The predicate function
+ * @param {Function} lens Van Laarhoven lens
+ * @param {*} data The data structure
+ * @return {boolean} `true` if the focused data structure satisfies the predicate, `false` otherwise
+ *
+ * @example
+ *
+ * RA.lensSatisfies(RA.isTrue, R.lensIndex(0), [false, true, 1]); // => false
+ * RA.lensSatisfies(RA.isTrue, R.lensIndex(1), [false, true, 1]); // => true
+ * RA.lensSatisfies(RA.isTrue, R.lensIndex(2), [false, true, 1]); // => false
+ * RA.lensSatisfies(R.identity, R.lensProp('x'), { x: 1 }); // => false
+ */
+var lensSatisfies = (0, _ramda.curryN)(3, function (predicate, lens, data) {
+  return (0, _ramda.pipe)((0, _ramda.view)(lens), predicate, _isTrue["default"])(data);
+});
+var _default = lensSatisfies;
+exports["default"] = _default;

package/lib/lensTraverse.js

@@ -0,0 +1,51 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _Identity = _interopRequireDefault(require("./fantasy-land/Identity"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Creates a [Traversable](https://github.com/fantasyland/fantasy-land#traversable) lens
+ * from an [Applicative](https://github.com/fantasyland/fantasy-land#applicative)-returning function.
+ *
+ * When executed, it maps an [Applicative](https://github.com/fantasyland/fantasy-land#applicative)-returning
+ * function over a [Traversable](https://github.com/fantasyland/fantasy-land#traversable),
+ * then uses [`sequence`](https://ramdajs.com/docs/#sequence) to transform the resulting Traversable of Applicative
+ * into an Applicative of Traversable.
+ *
+ * Dispatches to the `traverse` method of the third argument, if present.
+ *
+ * @func lensTraverse
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.7.0|2.7.0}
+ * @category Relation
+ * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s
+ * @sig Applicative f => (a -> f a) -> Lens s a
+ * @param {!function} of The Applicative-returning function
+ * @return {!function} The Traversable lens
+ * @see {@link http://ramdajs.com/docs/#lens|R.lens}, {@link http://ramdajs.com/docs/#traverse|R.traverse}
+ *
+ * @example
+ *
+ * const maybeLens = RA.lensTraverse(Maybe.of);
+ * const safeDiv = n => d => d === 0 ? Maybe.Nothing() : Maybe.Just(n / d)
+ *
+ * R.over(maybeLens, safeDiv(10), [2, 4, 5]); // => Just([5, 2.5, 2])
+ * R.over(maybeLens, safeDiv(10), [2, 0, 5]); // => Nothing
+ *
+ * R.view(maybeLens, [Maybe.Just(2), Maybe.Just(3)]); // => Maybe.Just([2, 3])
+ *
+ * R.set(maybeLens, Maybe.Just(1), [Maybe.just(2), Maybe.Just(3)]); // => Maybe.Just([1, 1])
+ */
+var lensTraverse = (0, _ramda.curryN)(1, function (of) {
+  return (0, _ramda.curry)(function (toFunctorFn, target) {
+    return _Identity["default"].of((0, _ramda.traverse)(of, (0, _ramda.pipe)(toFunctorFn, (0, _ramda.prop)('value')), target));
+  });
+});
+var _default = lensTraverse;
+exports["default"] = _default;

package/lib/liftF.js

@@ -0,0 +1,46 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _liftFN = _interopRequireDefault(require("./liftFN"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * "lifts" a function to be the specified arity, so that it may "map over" objects that satisfy
+ * the fantasy land Apply spec of algebraic structures.
+ *
+ * Lifting is specific for {@link https://github.com/scalaz/scalaz|scalaz} and {@link http://functionaljava.org/|function Java} implementations.
+ * Old version of fantasy land spec were not compatible with this approach,
+ * but as of fantasy land 1.0.0 Apply spec also adopted this approach.
+ *
+ * This function acts as interop for ramda <= 0.23.0 and {@link https://monet.github.io/monet.js/|monet.js}.
+ *
+ * More info {@link https://github.com/fantasyland/fantasy-land/issues/50|here}.
+ *
+ * @func liftF
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.2.0|v1.2.0}
+ * @category Function
+ * @sig Apply a => (a... -> a) -> (a... -> a)
+ * @param {Function} fn The function to lift into higher context
+ * @return {Function} The lifted function
+ * @see {@link RA.liftFN|liftFN}
+ * @example
+ *
+ * const { Maybe } = require('monet');
+ *
+ * const add3 = (a, b, c) => a + b + c;
+ * const madd3 = RA.liftF(add3);
+ *
+ * madd3(Maybe.Some(10), Maybe.Some(15), Maybe.Some(17)); //=> Maybe.Some(42)
+ * madd3(Maybe.Some(10), Maybe.Nothing(), Maybe.Some(17)); //=> Maybe.Nothing()
+ */
+var liftF = (0, _ramda.curryN)(1, function (fn) {
+  return (0, _liftFN["default"])(fn.length, fn);
+});
+var _default = liftF;
+exports["default"] = _default;

package/lib/liftFN.js

@@ -0,0 +1,56 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _ap = _interopRequireDefault(require("./internal/ap"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * "lifts" a function to be the specified arity, so that it may "map over" objects that satisfy
+ * the fantasy land Apply spec of algebraic structures.
+ *
+ * Lifting is specific for {@link https://github.com/scalaz/scalaz|scalaz} and {@link http://www.functionaljava.org/|functional java} implementations.
+ * Old version of fantasy land spec were not compatible with this approach,
+ * but as of fantasy land 1.0.0 Apply spec also adopted this approach.
+ *
+ * This function acts as interop for ramda <= 0.23.0 and {@link https://monet.github.io/monet.js/|monet.js}.
+ *
+ * More info {@link https://github.com/fantasyland/fantasy-land/issues/50|here}.
+ *
+ * @func liftFN
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.2.0|v1.2.0}
+ * @category Function
+ * @sig Apply a => Number -> (a... -> a) -> (a... -> a)
+ * @param {number} arity The arity of the lifter function
+ * @param {Function} fn The function to lift into higher context
+ * @return {Function} The lifted function
+ * @see {@link http://ramdajs.com/docs/#lift|R.lift}, {@link http://ramdajs.com/docs/#ap|R.ap}
+ * @example
+ *
+ * const { Maybe } = require('monet');
+ *
+ * const add3 = (a, b, c) => a + b + c;
+ * const madd3 = RA.liftFN(3, add3);
+ *
+ * madd3(Maybe.Some(10), Maybe.Some(15), Maybe.Some(17)); //=> Maybe.Some(42)
+ * madd3(Maybe.Some(10), Maybe.Nothing(), Maybe.Some(17)); //=> Maybe.Nothing()
+ */
+var liftFN = (0, _ramda.curry)(function (arity, fn) {
+  var lifted = (0, _ramda.curryN)(arity, fn);
+  return (0, _ramda.curryN)(arity, function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var accumulator = (0, _ramda.map)(lifted, (0, _ramda.head)(args));
+    var apps = (0, _ramda.slice)(1, Infinity, args);
+    return (0, _ramda.reduce)(_ap["default"], accumulator, apps);
+  });
+});
+var _default = liftFN;
+exports["default"] = _default;

package/lib/list.js

@@ -0,0 +1,25 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Creates a list from arguments.
+ *
+ * @func list
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.1.0|v1.1.0}
+ * @category List
+ * @sig  a... -> [a...]
+ * @param {...*} items The items of the feature list
+ * @return {Array} New list created from items
+ * @see {@link https://github.com/ramda/ramda/wiki/Cookbook#create-a-list-function|Ramda Cookbook}
+ * @example
+ *
+ * RA.list('a', 'b', 'c'); //=> ['a', 'b', 'c']
+ */
+var list = (0, _ramda.unapply)(_ramda.identity);
+var _default = list;
+exports["default"] = _default;

package/lib/mapIndexed.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * {@link http://ramdajs.com/docs/#map|R.map} function that more closely resembles Array.prototype.map.
+ * It takes two new parameters to its callback function: the current index, and the entire list.
+ *
+ * `mapIndexed` implementation is simple : `
+ * const mapIndexed = R.addIndex(R.map);
+ * `
+ * @func mapIndexed
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
+ * @category List
+ * @typedef Idx = Number
+ * @sig Functor f => ((a, Idx, f a) => b) => f a -> f b
+ * @param {Function} fn The function to be called on every element of the input `list`
+ * @param {Array} list The list to be iterated over
+ * @return {Array} The new list
+ * @see {@link http://ramdajs.com/docs/#addIndex|R.addIndex}, {@link http://ramdajs.com/docs/#map|R.map}
+ * @example
+ *
+ * RA.mapIndexed((val, idx, list) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r']);
+ * //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']
+ */
+var mapIndexed = (0, _ramda.addIndex)(_ramda.map);
+var _default = mapIndexed;
+exports["default"] = _default;

package/lib/mergePath.js

@@ -0,0 +1,39 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _mergeRight = _interopRequireDefault(require("./mergeRight"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Create a new object with the own properties of the object under the `path`
+ * merged with the own properties of the provided `source`.
+ * If a key exists in both objects, the value from the `source` object will be used.
+ *
+ * @func mergePath
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.18.0|v1.18.0}
+ * @category Object
+ * @sig [k] -> {a} -> {k: {a}} -> {k: {a}}
+ * @see {@link RA.mergeProp|mergeProp}
+ * @param {!Array} path The property path of the destination object
+ * @param {!Object} source The source object
+ * @param {!Object} obj The object that has destination object under corresponding property path
+ * @return {!Object} The new version of object
+ * @example
+ *
+ * RA.mergePath(
+ *  ['outer', 'inner'],
+ *  { foo: 3, bar: 4 },
+ *  { outer: { inner: { foo: 2 } } }
+ * ); //=> { outer: { inner: { foo: 3, bar: 4 } }
+ */
+var mergePath = (0, _ramda.curry)(function (path, source, obj) {
+  return (0, _ramda.over)((0, _ramda.lensPath)(path), (0, _mergeRight["default"])(source), obj);
+});
+var _default = mergePath;
+exports["default"] = _default;

package/lib/mergePaths.js

@@ -0,0 +1,36 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _paths = _interopRequireDefault(require("./paths"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Merge objects under corresponding paths.
+ *
+ * @func mergePaths
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.17.0|v1.17.0}
+ * @category Object
+ * @sig [[k]] -> {k: {a}} -> {a}
+ * @see {@link RA.mergeProps|mergeProps}
+ * @param {!Array} paths The property paths to merge
+ * @param {!Object} obj The object to query
+ * @return {!Object} The object composed of merged property paths of obj
+ * @example
+ *
+ * const obj = {
+ *   foo: { fooInner: { fooInner2: 1 } },
+ *   bar: { barInner: 2 }
+ * };
+ *
+ * { ...obj.foo.fooInner, ...obj.bar }; //=>  { fooInner2: 1, barInner: 2 }
+ * RA.mergePaths([['foo', 'fooInner'], ['bar']], obj); //=> { fooInner2: 1, barInner: 2 }
+ */
+var mergePaths = (0, _ramda.curryN)(2, (0, _ramda.pipe)(_paths["default"], _ramda.mergeAll));
+var _default = mergePaths;
+exports["default"] = _default;

package/lib/mergeProp.js

@@ -0,0 +1,39 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _mergePath = _interopRequireDefault(require("./mergePath"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Create a new object with the own properties of the object under the `p`
+ * merged with the own properties of the provided `source`.
+ * If a key exists in both objects, the value from the `source` object will be used.
+ *
+ * @func mergeProp
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.18.0|v1.18.0}
+ * @category Object
+ * @sig [k] -> {a} -> {k: {a}} -> {k: {a}}
+ * @see {@link RA.mergePath|mergePath}
+ * @param {!Array} p The property of the destination object
+ * @param {!Object} source The source object
+ * @param {!Object} obj The object that has destination object under corresponding property
+ * @return {!Object} The new version of object
+ * @example
+ *
+ * RA.mergeProp(
+ *  'outer',
+ *  { foo: 3, bar: 4 },
+ *  { outer: { foo: 2 } }
+ * ); //=> { outer: { foo: 3, bar: 4 } };
+ */
+var mergeProp = (0, _ramda.curry)(function (p, subj, obj) {
+  return (0, _mergePath["default"])((0, _ramda.of)(p), subj, obj);
+});
+var _default = mergeProp;
+exports["default"] = _default;

package/lib/mergeProps.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Functional equivalent of merging object properties with object spread operator.
+ *
+ * @func mergeProps
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.17.0|v1.17.0}
+ * @category Object
+ * @sig [k] -> {k: {a}} -> {a}
+ * @see {@link RA.mergePaths|mergePaths}
+ * @param {!Array} ps The property names to merge
+ * @param {!Object} obj The object to query
+ * @return {!Object} The object composed of merged properties of obj
+ * @example
+ *
+ * const obj = {
+ *   foo: { fooInner: 1 },
+ *   bar: { barInner: 2 }
+ * };
+ *
+ * { ...obj.foo, ...obj.bar }; //=> { fooInner: 1, barInner: 2 }
+ * RA.mergeProps(['foo', 'bar'], obj); //=> { fooInner: 1, barInner: 2 }
+ */
+var mergeProps = (0, _ramda.curryN)(2, (0, _ramda.pipe)(_ramda.props, _ramda.mergeAll));
+var _default = mergeProps;
+exports["default"] = _default;

package/lib/mergeRight.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Create a new object with the own properties of the second object merged with
+ * the own properties of the first object. If a key exists in both objects,
+ * the value from the first object will be used. *
+ * Putting it simply: it sets properties only if they don't exist.
+ *
+ * @func mergeRight
+ * @deprecated since v2.12.0; available in ramda@0.26.0 as R.mergeLeft
+ * @aliases mergeLeft, resetToDefault
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.6.0|v1.6.0}
+ * @category Object
+ * @sig {k: v} -> {k: v} -> {k: v}
+ * @param {Object} r Destination
+ * @param {Object} l Source
+ * @return {Object}
+ * @see {@link http://ramdajs.com/docs/#merge|R.merge}, {@link https://github.com/ramda/ramda/wiki/Cookbook#set-properties-only-if-they-dont-exist|Ramda Cookbook}
+ * @example
+ *
+ * RA.mergeRight({ 'age': 40 }, { 'name': 'fred', 'age': 10 });
+ * //=> { 'name': 'fred', 'age': 40 }
+ */
+var mergeRight = (0, _ramda.flip)(_ramda.merge);
+var _default = mergeRight;
+exports["default"] = _default;