ramda-adjunct 2.34.0

package/lib/fantasy-land/Identity.js

@@ -0,0 +1,323 @@
+"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"] = void 0;
+
+var _ramda = require("ramda");
+
+var fl = _interopRequireWildcard(require("./mapping"));
+
+var _traits = require("./traits");
+
+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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+/**
+ * The simplest {@link https://github.com/fantasyland/fantasy-land|fantasy-land}
+ * compatible monad which attaches no information to values.
+ *
+ * The Identity type is a very simple type that has no interesting side effects and
+ * is effectively just a container of some value. So why does it exist ?
+ * The Identity type is often used as the base monad of a monad
+ * transformer when no other behaviour is required.
+ *
+ * @memberOf RA
+ * @implements
+ * {@link https://github.com/fantasyland/fantasy-land#apply|Apply},
+ * {@link https://github.com/fantasyland/fantasy-land#applicative|Applicative},
+ * {@link https://github.com/fantasyland/fantasy-land#functor|Functor},
+ * {@link https://github.com/fantasyland/fantasy-land#setoid|Setoid},
+ * {@link https://github.com/fantasyland/fantasy-land#semigroup|Semigroup},
+ * {@link https://github.com/fantasyland/fantasy-land#chain|Chain},
+ * {@link https://github.com/fantasyland/fantasy-land#monad|Monad},
+ * {@link https://github.com/fantasyland/fantasy-land#ord|Ord},
+ * {@link https://github.com/fantasyland/fantasy-land#monoid|Monoid*},
+ * {@link https://github.com/fantasyland/fantasy-land#contravariant|Contravariant}
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.8.0|v1.8.0}
+ */
+var Identity = /*#__PURE__*/function (_fl$of, _fl$ap, _fl$map, _fl$equals, _fl$concat, _fl$chain, _fl$lte, _fl$empty, _fl$contramap) {
+  /**
+   * Private constructor. Use {@link RA.Identity.of|Identity.of} instead.
+   *
+   * @param {*} value
+   * @return {RA.Identity}
+   */
+  function Identity(value) {
+    _classCallCheck(this, Identity);
+
+    this.value = value;
+  }
+  /**
+   * Catamorphism for a value.
+   * @returns {*}
+   * @example
+   *
+   * const a = Identity.of(1);
+   * a.get(); //=> 1
+   */
+
+
+  _createClass(Identity, [{
+    key: "get",
+    value: function get() {
+      return this.value;
+    }
+    /**
+     * Fantasy land {@link https://github.com/fantasyland/fantasy-land#apply|Apply} specification.
+     *
+     * @sig ap :: Apply f => f a ~> f (a -> b) -> f b
+     * @param {RA.Identity} applyWithFn
+     * @return {RA.Identity}
+     * @example
+     *
+     * const a = Identity.of(1);
+     * const b = Identity.of(1).map(a => b => a + b);
+     *
+     * a.ap(b); //=> Identity(2)
+     */
+
+  }, {
+    key: _fl$ap,
+    value: function value(applyWithFn) {
+      return _traits.applyTrait[fl.ap].call(this, applyWithFn);
+    }
+  }, {
+    key: "ap",
+    value: function ap(applyWithFn) {
+      return this[fl.ap](applyWithFn);
+    }
+    /**
+     * Fantasy land {@link https://github.com/fantasyland/fantasy-land#functor|Functor} specification.
+     *
+     * @sig map :: Functor f => f a ~> (a -> b) -> f b
+     * @param {Function} fn
+     * @return {RA.Identity}
+     * @example
+     *
+     * const a = Identity.of(1);
+     * a.map(a => a + 1); //=> Identity(2)
+     */
+
+  }, {
+    key: _fl$map,
+    value: function value(fn) {
+      return _traits.functorTrait[fl.map].call(this, fn);
+    }
+  }, {
+    key: "map",
+    value: function map(fn) {
+      return this[fl.map](fn);
+    }
+    /**
+     * Fantasy land {@link https://github.com/fantasyland/fantasy-land#setoid|Setoid} specification.
+     *
+     * @sig equals :: Setoid a => a ~> a -> Boolean
+     * @param {RA.Identity} setoid
+     * @return {boolean}
+     * @example
+     *
+     * const a = Identity.of(1);
+     * const b = Identity.of(1);
+     * const c = Identity.of(2);
+     *
+     * a.equals(b); //=> true
+     * a.equals(c); //=> false
+     */
+
+  }, {
+    key: _fl$equals,
+    value: function value(setoid) {
+      return _traits.setoidTrait[fl.equals].call(this, setoid);
+    }
+  }, {
+    key: "equals",
+    value: function equals(setoid) {
+      return this[fl.equals](setoid);
+    }
+    /**
+     * Fantasy land {@link https://github.com/fantasyland/fantasy-land#semigroup|Semigroup} specification.
+     *
+     * @sig concat :: Semigroup a => a ~> a -> a
+     * @param {RA.Identity} semigroup
+     * @return {RA.Identity}
+     * @example
+     *
+     * const a = Identity.of(1);
+     * const b = Identity.of(1);
+     * a.concat(b); //=> 2
+     *
+     * const c = Identity.of('c');
+     * const d = Identity.of('d');
+     * c.concat(d); //=> 'cd'
+     *
+     * const e = Identity.of(['e']);
+     * const f = Identity.of(['f']);
+     * e.concat(f); //=> ['e', 'f']
+     */
+
+  }, {
+    key: _fl$concat,
+    value: function value(semigroup) {
+      return _traits.semigroupTrait[fl.concat].call(this, semigroup);
+    }
+  }, {
+    key: "concat",
+    value: function concat(semigroup) {
+      return this[fl.concat](semigroup);
+    }
+    /**
+     * Fantasy land {@link https://github.com/fantasyland/fantasy-land#chain|Chain} specification.
+     *
+     * @sig chain :: Chain m => m a ~> (a -> m b) -> m b
+     * @param {Function} fn Function returning the value of the same {@link https://github.com/fantasyland/fantasy-land#semigroup|Chain}
+     * @return {RA.Identity}
+     * @example
+     *
+     * const a = Identity.of(1);
+     * const fn = val => Identity.of(val + 1);
+     *
+     * a.chain(fn).chain(fn); //=> Identity(3)
+     */
+
+  }, {
+    key: _fl$chain,
+    value: function value(fn) {
+      return _traits.chainTrait[fl.chain].call(this, fn);
+    }
+  }, {
+    key: "chain",
+    value: function chain(fn) {
+      return this[fl.chain](fn);
+    }
+    /**
+     * Fantasy land {@link https://github.com/fantasyland/fantasy-land#ord|Ord} specification.
+     *
+     * @sig lte :: Ord a => a ~> a -> Boolean
+     * @param {RA.Identity} ord
+     * @return {boolean}
+     * @example
+     *
+     * const a = Identity.of(1);
+     * const b = Identity.of(1);
+     * const c = Identity.of(2);
+     *
+     * a.lte(b); //=> true
+     * a.lte(c); //=> true
+     * c.lte(a); //=> false
+     */
+
+  }, {
+    key: _fl$lte,
+    value: function value(ord) {
+      return _traits.ordTrait[fl.lte].call(this, ord);
+    }
+  }, {
+    key: "lte",
+    value: function lte(ord) {
+      return this[fl.lte](ord);
+    }
+    /**
+     * Fantasy land {@link https://github.com/fantasyland/fantasy-land#monoid|Monoid*} specification.
+     * Partial implementation of Monoid specification. `empty` method on instance only, returning
+     * identity value of the wrapped type. Using `R.empty` under the hood.
+     *
+     *
+     * @sig empty :: Monoid m => () -> m
+     * @return {RA.Identity}
+     * @example
+     *
+     * const a = Identity.of('test');
+     * const i = a.empty();
+     *
+     * a.concat(i); //=> Identity('string');
+     * i.concat(a); //=> Identity('string');
+     */
+
+  }, {
+    key: _fl$empty,
+    value: function value() {
+      return this.constructor.of((0, _ramda.empty)(this.value));
+    }
+  }, {
+    key: "empty",
+    value: function empty() {
+      return this[fl.empty]();
+    }
+    /**
+     * Fantasy land {@link https://github.com/fantasyland/fantasy-land#contravariant|Contravariant} specification.
+     *
+     * @sig contramap :: Contravariant f => f a ~> (b -> a) -> f b
+     * @param {Function} fn
+     * @return {RA.Identity}
+     * @example
+     *
+     * const identity = a => a;
+     * const add1 = a => a + 1;
+     * const divide2 = a => a / 2;
+     *
+     * Identity.of(divide2).contramap(add1).get()(3); //=> 2
+     * Identity.of(identity).contramap(divide2).contramap(add1).get()(3); //=> 2
+     * Identity.of(identity).contramap(a => divide2(add1(a))).get()(3); //=> 2
+     */
+
+  }, {
+    key: _fl$contramap,
+    value: function value(fn) {
+      var _this = this;
+
+      return this.constructor.of(function (value) {
+        return _this.value(fn(value));
+      });
+    }
+  }, {
+    key: "contramap",
+    value: function contramap(fn) {
+      return this[fl.contramap](fn);
+    }
+  }], [{
+    key: _fl$of,
+    value:
+    /**
+     * Fantasy land {@link https://github.com/fantasyland/fantasy-land#applicative|Applicative} specification.
+     *
+     * @static
+     * @sig of :: Applicative f => a -> f a
+     * @param {*} value
+     * @returns {RA.Identity}
+     * @example
+     *
+     * const a = Identity.of(1); //=> Identity(1)
+     */
+    function value(_value) {
+      return new Identity(_value);
+    }
+  }, {
+    key: "of",
+    value: function of(value) {
+      return new Identity(value);
+    }
+    /**
+     * @static
+     */
+
+  }, {
+    key: '@@type',
+    get: function get() {
+      return 'RA/Identity';
+    }
+  }]);
+
+  return Identity;
+}(fl.of, fl.ap, fl.map, fl.equals, fl.concat, fl.chain, fl.lte, fl.empty, fl.contramap);
+
+var _default = Identity;
+exports["default"] = _default;

package/lib/fantasy-land/mapping.js

@@ -0,0 +1,44 @@
+"use strict";
+
+exports.__esModule = true;
+exports.promap = exports.bimap = exports.extract = exports.extend = exports.chainRec = exports.chain = exports.traverse = exports.reduce = exports.zero = exports.alt = exports.of = exports.ap = exports.contramap = exports.map = exports.empty = exports.concat = exports.id = exports.compose = exports.lte = exports.equals = void 0;
+var equals = 'fantasy-land/equals';
+exports.equals = equals;
+var lte = 'fantasy-land/lte';
+exports.lte = lte;
+var compose = 'fantasy-land/compose';
+exports.compose = compose;
+var id = 'fantasy-land/id';
+exports.id = id;
+var concat = 'fantasy-land/concat';
+exports.concat = concat;
+var empty = 'fantasy-land/empty';
+exports.empty = empty;
+var map = 'fantasy-land/map';
+exports.map = map;
+var contramap = 'fantasy-land/contramap';
+exports.contramap = contramap;
+var ap = 'fantasy-land/ap';
+exports.ap = ap;
+var of = 'fantasy-land/of';
+exports.of = of;
+var alt = 'fantasy-land/alt';
+exports.alt = alt;
+var zero = 'fantasy-land/zero';
+exports.zero = zero;
+var reduce = 'fantasy-land/reduce';
+exports.reduce = reduce;
+var traverse = 'fantasy-land/traverse';
+exports.traverse = traverse;
+var chain = 'fantasy-land/chain';
+exports.chain = chain;
+var chainRec = 'fantasy-land/chainRec';
+exports.chainRec = chainRec;
+var extend = 'fantasy-land/extend';
+exports.extend = extend;
+var extract = 'fantasy-land/extract';
+exports.extract = extract;
+var bimap = 'fantasy-land/bimap';
+exports.bimap = bimap;
+var promap = 'fantasy-land/promap';
+exports.promap = promap;

package/lib/fantasy-land/traits.js

@@ -0,0 +1,77 @@
+"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.ordTrait = exports.chainTrait = exports.semigroupTrait = exports.setoidTrait = exports.applyTrait = exports.functorTrait = void 0;
+
+var _ramda = require("ramda");
+
+var _isString = _interopRequireDefault(require("../isString"));
+
+var _isNumber = _interopRequireDefault(require("../isNumber"));
+
+var _isFunction = _interopRequireDefault(require("../isFunction"));
+
+var _util = require("./util");
+
+var fl = _interopRequireWildcard(require("./mapping"));
+
+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 }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var functorTrait = _defineProperty({}, fl.map, function (fn) {
+  return this.constructor[fl.of](fn(this.value));
+});
+
+exports.functorTrait = functorTrait;
+
+var applyTrait = _defineProperty({}, fl.ap, function (applyWithFn) {
+  var _this = this;
+
+  return applyWithFn.map(function (fn) {
+    return fn(_this.value);
+  });
+});
+
+exports.applyTrait = applyTrait;
+
+var setoidTrait = _defineProperty({}, fl.equals, function (setoid) {
+  return (0, _util.isSameType)(this, setoid) && (0, _ramda.equals)(this.value, setoid.value);
+});
+
+exports.setoidTrait = setoidTrait;
+
+var semigroupTrait = _defineProperty({}, fl.concat, function (semigroup) {
+  var concatenatedValue = this.value;
+
+  if ((0, _isString["default"])(this.value) || (0, _isNumber["default"])(this.value)) {
+    concatenatedValue = this.value + semigroup.value;
+  } else if ((0, _ramda.pathSatisfies)(_isFunction["default"], ['value', fl.concat], this)) {
+    concatenatedValue = this.value[fl.concat](semigroup.value);
+  } else if ((0, _ramda.pathSatisfies)(_isFunction["default"], ['value', 'concat'], this)) {
+    concatenatedValue = this.value.concat(semigroup.value);
+  }
+
+  return this.constructor[fl.of](concatenatedValue);
+});
+
+exports.semigroupTrait = semigroupTrait;
+
+var chainTrait = _defineProperty({}, fl.chain, function (fn) {
+  var newChain = fn(this.value);
+  return (0, _util.isSameType)(this, newChain) ? newChain : this;
+});
+
+exports.chainTrait = chainTrait;
+
+var ordTrait = _defineProperty({}, fl.lte, function (ord) {
+  return (0, _util.isSameType)(this, ord) && (this.value < ord.value || this[fl.equals](ord));
+});
+
+exports.ordTrait = ordTrait;

package/lib/fantasy-land/util.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isNotSameType = exports.isSameType = exports.typeEquals = exports.type = void 0;
+
+var _ramda = require("ramda");
+
+// type :: Monad a => a -> String
+var type = (0, _ramda.either)((0, _ramda.path)(['@@type']), (0, _ramda.path)(['constructor', '@@type'])); // typeEquals :: Monad a => String -> a -> Boolean
+
+exports.type = type;
+var typeEquals = (0, _ramda.curry)(function (typeIdent, monad) {
+  return type(monad) === typeIdent;
+}); // isSameType :: (Monad a, Monad b) => a -> b -> Boolean
+
+exports.typeEquals = typeEquals;
+var isSameType = (0, _ramda.curryN)(2, (0, _ramda.useWith)(_ramda.equals, [type, type])); // isNotSameType :: (Monad a, Monad b) => a -> b -> Boolean
+
+exports.isSameType = isSameType;
+var isNotSameType = (0, _ramda.complement)(isSameType);
+exports.isNotSameType = isNotSameType;

package/lib/filterIndexed.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * {@link http://ramdajs.com/docs/#filter|R.filter} function that more closely resembles `Array.prototype.filter`.
+ * It takes two new parameters to its callback function: the current index, and the entire list.
+ *
+ * `filterIndexed` implementation is simple: `
+ *  const filterIndexed = R.addIndex(R.filter);
+ * `
+ *
+ * @func filterIndexed
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.31.0|v2.31.0}
+ * @category List
+ * @typedef Idx = Number
+ * @sig Filterable f => ((a, Idx, f a) -> Boolean) -> f a -> f a
+ * @param {Function} pred The predicate function
+ * @param {Array} list The collection to filter
+ * @return {Array} Filterable
+ * @see {@link http://ramdajs.com/docs/#addIndex|R.addIndex}, {@link http://ramdajs.com/docs/#filter|R.filter}
+ * @example
+ *
+ * const isValueGtIndex = (val, idx) => val > idx;
+ * RA.filterIndexed(isValueGtIndex, [5, 4, 3, 2, 1, 0]); //=> [5, 4, 3]
+ */
+var filterIndexed = (0, _ramda.addIndex)(_ramda.filter);
+var _default = filterIndexed;
+exports["default"] = _default;

package/lib/findOr.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns the first element of the list which matches the predicate.
+ * Returns default value if no element matches or matched element is `null`, `undefined` or `NaN`.
+ * Dispatches to the find method of the second argument, if present.
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func findOr
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.32.0|v2.32.0}
+ * @category List
+ * @sig  a -> (b -> Boolean) -> [b] -> b | a
+ * @param {*} defaultValue The default value
+ * @param {Function} fn The predicate function used to determine if the element is the desired one.
+ * @param {Array} list The array to consider.
+ * @return {*} The element found, or the default value.
+ * @see {@link http://ramdajs.com/docs/#defaultTo|R.defaultTo}, {@link http://ramdajs.com/docs/#find|R.find}
+ * @example
+ *
+ * RA.findOr(1, isUndefined, [1, 2, undefined]); // => 1
+ * RA.findOr(1, val => val === 2, [1, 2, undefined]); // => 2
+ * RA.findOr(1, val => val === 3, [1, 2, undefined]); // => 1
+ */
+var findOr = (0, _ramda.curry)(function (defaultVal, fn, list) {
+  return (0, _ramda.pipe)((0, _ramda.find)(fn), (0, _ramda.defaultTo)(defaultVal))(list);
+});
+var _default = findOr;
+exports["default"] = _default;

package/lib/flattenDepth.js

@@ -0,0 +1,58 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _makeFlat2 = _interopRequireDefault(require("./internal/makeFlat"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread 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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+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; }
+
+var flatten1 = (0, _makeFlat2["default"])(false);
+/**
+ * Flattens the list to the specified depth.
+ *
+ * @func flattenDepth
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.19.0|v2.19.0}
+ * @category List
+ * @sig Number -> [a] -> [b]
+ * @param {!number} depth The maximum recursion depth
+ * @param {!Array} list The array to flatten
+ * @return {!Array} Returns the new flattened array
+ * @see {@link http://ramdajs.com/docs/#flatten|R.flatten}, {@link http://ramdajs.com/docs/#unnest|R.unnest}
+ * @example
+ *
+ * RA.flattenDepth(
+ *   2,
+ *   [1, [2], [3, [4, 5], 6, [[[7], 8]]], 9, 10]
+ * ); //=> [1, 2, 3, 4, 5, 6, [[7], 8], 9, 10];
+ */
+
+var flattenDepth = (0, _ramda.curry)(function (depth, list) {
+  var currentDept = depth;
+
+  var flatList = _toConsumableArray(list);
+
+  while (currentDept > 0) {
+    flatList = flatten1(flatList);
+    currentDept -= 1;
+  }
+
+  return flatList;
+});
+var _default = flattenDepth;
+exports["default"] = _default;

package/lib/flattenPath.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Flattens a property path so that its fields are spread out into the provided object.
+ * It's like {@link RA.spreadPath|spreadPath}, but preserves object under the property path.
+ *
+ * @func flattenPath
+ * @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 flatten
+ * @param {!Object} obj The provided object
+ * @return {!Object} The flattened object
+ * @see {@link RA.flattenProp|flattenProp}, {@link RA.spreadPath|spreadPath}
+ * @example
+ *
+ * RA.flattenPath(
+ *   ['b1', 'b2'],
+ *   { a: 1, b1: { b2: { c: 3, d: 4 } } }
+ * ); // => { a: 1, c: 3, d: 4, b1: { b2: { c: 3, d: 4 } } };
+ */
+var flattenPath = (0, _ramda.curry)(function (path, obj) {
+  return (0, _ramda.merge)(obj, (0, _ramda.pathOr)({}, path, obj));
+});
+var _default = flattenPath;
+exports["default"] = _default;

package/lib/flattenProp.js

@@ -0,0 +1,37 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _flattenPath = _interopRequireDefault(require("./flattenPath"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Flattens a property so that its fields are spread out into the provided object.
+ * It's like {@link RA.spreadProp|spreadProp}, but preserves object under the property path.
+ *
+ * @func flattenProp
+ * @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 flatten
+ * @param {!Object} obj The provided object
+ * @return {!Object} The flattened object
+ * @see {@link RA.flattenPath|flattenPath}, {@link RA.spreadProp|spreadProp}
+ * @example
+ *
+ * RA.flattenProp(
+ *   'b',
+ *   { a: 1, b: { c: 3, d: 4 } }
+ * ); // => { a: 1, c: 3, d: 4, b: { c: 3, d: 4 } };
+ */
+var flattenProp = (0, _ramda.curry)(function (prop, obj) {
+  return (0, _flattenPath["default"])((0, _ramda.of)(prop), obj);
+});
+var _default = flattenProp;
+exports["default"] = _default;