ramda-adjunct 2.34.0

package/es/fantasy-land/Identity.js

@@ -0,0 +1,309 @@
+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; }
+
+import { empty as emptyR } from 'ramda';
+import * as fl from './mapping';
+import { applyTrait, functorTrait, setoidTrait, semigroupTrait, chainTrait, ordTrait } from './traits';
+/**
+ * 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 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 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 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 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 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 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(emptyR(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);
+
+export default Identity;

package/es/fantasy-land/mapping.js

@@ -0,0 +1,20 @@
+export var equals = 'fantasy-land/equals';
+export var lte = 'fantasy-land/lte';
+export var compose = 'fantasy-land/compose';
+export var id = 'fantasy-land/id';
+export var concat = 'fantasy-land/concat';
+export var empty = 'fantasy-land/empty';
+export var map = 'fantasy-land/map';
+export var contramap = 'fantasy-land/contramap';
+export var ap = 'fantasy-land/ap';
+export var of = 'fantasy-land/of';
+export var alt = 'fantasy-land/alt';
+export var zero = 'fantasy-land/zero';
+export var reduce = 'fantasy-land/reduce';
+export var traverse = 'fantasy-land/traverse';
+export var chain = 'fantasy-land/chain';
+export var chainRec = 'fantasy-land/chainRec';
+export var extend = 'fantasy-land/extend';
+export var extract = 'fantasy-land/extract';
+export var bimap = 'fantasy-land/bimap';
+export var promap = 'fantasy-land/promap';

package/es/fantasy-land/traits.js

@@ -0,0 +1,41 @@
+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; }
+
+import { equals, pathSatisfies } from 'ramda';
+import isString from '../isString';
+import isNumber from '../isNumber';
+import isFunction from '../isFunction';
+import { isSameType } from './util';
+import * as fl from './mapping';
+export var functorTrait = _defineProperty({}, fl.map, function (fn) {
+  return this.constructor[fl.of](fn(this.value));
+});
+export var applyTrait = _defineProperty({}, fl.ap, function (applyWithFn) {
+  var _this = this;
+
+  return applyWithFn.map(function (fn) {
+    return fn(_this.value);
+  });
+});
+export var setoidTrait = _defineProperty({}, fl.equals, function (setoid) {
+  return isSameType(this, setoid) && equals(this.value, setoid.value);
+});
+export var semigroupTrait = _defineProperty({}, fl.concat, function (semigroup) {
+  var concatenatedValue = this.value;
+
+  if (isString(this.value) || isNumber(this.value)) {
+    concatenatedValue = this.value + semigroup.value;
+  } else if (pathSatisfies(isFunction, ['value', fl.concat], this)) {
+    concatenatedValue = this.value[fl.concat](semigroup.value);
+  } else if (pathSatisfies(isFunction, ['value', 'concat'], this)) {
+    concatenatedValue = this.value.concat(semigroup.value);
+  }
+
+  return this.constructor[fl.of](concatenatedValue);
+});
+export var chainTrait = _defineProperty({}, fl.chain, function (fn) {
+  var newChain = fn(this.value);
+  return isSameType(this, newChain) ? newChain : this;
+});
+export var ordTrait = _defineProperty({}, fl.lte, function (ord) {
+  return isSameType(this, ord) && (this.value < ord.value || this[fl.equals](ord));
+});

package/es/fantasy-land/util.js

@@ -0,0 +1,11 @@
+import { useWith, curry, curryN, equals, path, either, complement } from 'ramda'; // type :: Monad a => a -> String
+
+export var type = either(path(['@@type']), path(['constructor', '@@type'])); // typeEquals :: Monad a => String -> a -> Boolean
+
+export var typeEquals = curry(function (typeIdent, monad) {
+  return type(monad) === typeIdent;
+}); // isSameType :: (Monad a, Monad b) => a -> b -> Boolean
+
+export var isSameType = curryN(2, useWith(equals, [type, type])); // isNotSameType :: (Monad a, Monad b) => a -> b -> Boolean
+
+export var isNotSameType = complement(isSameType);

package/es/filterIndexed.js

@@ -0,0 +1,27 @@
+import { addIndex, filter } from '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 = addIndex(filter);
+export default filterIndexed;

package/es/findOr.js

@@ -0,0 +1,28 @@
+import { pipe, curry, find, defaultTo } from '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 = curry(function (defaultVal, fn, list) {
+  return pipe(find(fn), defaultTo(defaultVal))(list);
+});
+export default findOr;

package/es/flattenDepth.js

@@ -0,0 +1,50 @@
+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; }
+
+import { curry } from 'ramda';
+import _makeFlat from './internal/makeFlat';
+
+var flatten1 = _makeFlat(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 = curry(function (depth, list) {
+  var currentDept = depth;
+
+  var flatList = _toConsumableArray(list);
+
+  while (currentDept > 0) {
+    flatList = flatten1(flatList);
+    currentDept -= 1;
+  }
+
+  return flatList;
+});
+export default flattenDepth;

package/es/flattenPath.js

@@ -0,0 +1,27 @@
+import { pathOr, curry, merge } from '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 = curry(function (path, obj) {
+  return merge(obj, pathOr({}, path, obj));
+});
+export default flattenPath;

package/es/flattenProp.js

@@ -0,0 +1,28 @@
+import { of, curry } from 'ramda';
+import flattenPath from './flattenPath';
+/**
+ * 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 = curry(function (prop, obj) {
+  return flattenPath(of(prop), obj);
+});
+export default flattenProp;

package/es/floor.js

@@ -0,0 +1,25 @@
+import { bind, curryN } from 'ramda';
+/**
+ * Returns the largest integer less than or equal to a given number.
+ *
+ * Note: floor(null) returns integer 0 and do not give a NaN error.
+ *
+ * @func floor
+ * @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 floor
+ * @return {number} A number representing the largest integer less than or equal to the specified number
+ * @example
+ *
+ * RA.floor(45.95); //=> 45
+ * RA.floor(45.05); //=> 45
+ * RA.floor(4); //=> 4
+ * RA.floor(-45.05); //=> -46
+ * RA.floor(-45.95); //=> -46
+ * RA.floor(null); //=> 0
+ */
+
+var floor = curryN(1, bind(Math.floor, Math));
+export default floor;

package/es/fnull.js

@@ -0,0 +1,37 @@
+import { isNil, curryN, curry, apply } from 'ramda';
+import defaultWhen from './defaultWhen';
+import mapIndexed from './mapIndexed';
+/**
+ * Returns a function which is called with the given arguments. If any of the given arguments are null or undefined,
+ * the corresponding default value for that argument is used instead.
+ *
+ * @func fnull
+ * @memberOf RA
+ * @category Function
+ * @sig (a ... -> b) -> [c] -> a ... | c -> b
+ * @param {Function} function to be executed
+ * @param {Array} defaults default arguments
+ * @return {Function} will apply provided arguments or default ones
+ * @example
+ *
+ * const addDefaults = RA.fnull((a, b) => a + b, [4, 5])
+ *
+ * addDefaults(1, 2); // => 3
+ * addDefaults(null, 2); // => 6
+ * addDefaults(2, null); // => 7
+ * addDefaults(undefined, undefined); // => 9
+ */
+
+var fnull = curry(function (fn, defaults) {
+  return curryN(fn.length, function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var argsWithDefaults = mapIndexed(function (val, idx) {
+      return defaultWhen(isNil, defaults[idx], val);
+    }, args);
+    return apply(fn, argsWithDefaults);
+  });
+});
+export default fnull;

package/es/hasPath.js

@@ -0,0 +1,38 @@
+import { length, has, path, head, tail, curryN } from 'ramda';
+import isObj from './isObj';
+/**
+ * Returns whether or not an object has an own property with the specified name at a given path.
+ *
+ * @func hasPath
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.14.0|v1.14.0}
+ * @deprecated since v2.12.0; ramda@0.26.0 contains hasPath
+ * @category Object
+ * @typedef Idx = String | Int
+ * @sig [Idx] -> {a} -> Boolean
+ * @param {Array.<string|number>} path The path of the nested property
+ * @param {Object} obj The object to test
+ * @return {boolean}
+ * @see {@link http://ramdajs.com/docs/#has|R.has}
+ * @example
+ *
+ * RA.hasPath(['a', 'b'], { a: { b: 1 } }); //=> true
+ * RA.hasPath(['a', 'b', 'c'], { a: { b: 1 } }); //=> false
+ * RA.hasPath(['a', 'b'], { a: { } }); //=> false
+ * RA.hasPath([0], [1, 2]); //=> true
+ */
+
+var hasPath = curryN(2, function (objPath, obj) {
+  var prop = head(objPath); // termination conditions
+
+  if (length(objPath) === 0 || !isObj(obj)) {
+    return false;
+  }
+
+  if (length(objPath) === 1) {
+    return has(prop, obj);
+  }
+
+  return hasPath(tail(objPath), path([prop], obj)); // base case
+});
+export default hasPath;

package/es/inRange.js

@@ -0,0 +1,29 @@
+import { ifElse, curry, useWith, both, gte, lte, gt } from 'ramda';
+var inRangeImp = ifElse(gte, function () {
+  throw new Error('low must not be greater than high in inRange(low, high, value)');
+}, useWith(both, [lte, gt]));
+/**
+ * Checks if `value` is between `low` and up to but not including `high`.
+ *
+ * @func inRange
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.7.0|v2.7.0}
+ * @category Relation
+ * @sig Number -> Number -> Number -> Boolean
+ * @param {number} low Start of the range
+ * @param {number} high The end of the range
+ * @param {number} value The value to test
+ * @return {boolean}
+ * @throws {Error} When `low` is greater than or equal to `high`
+ * @example
+ *
+ * RA.inRange(0, 5, 3); //=> true
+ * RA.inRange(0, 5, 0); //=> true
+ * RA.inRange(0, 5, 4); //=> true
+ * RA.inRange(0, 5, 5); //=> false
+ * RA.inRange(0, 5, -1); //=> false
+ */
+
+export default curry(function (low, high, value) {
+  return inRangeImp(low, high)(value);
+});