ramda-adjunct 2.34.0

package/lib/isRegExp.js

@@ -0,0 +1,27 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Checks if value is `RegExp` object.
+ *
+ * @func isRegExp
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotRegExp|isNotRegExp}
+ * @example
+ *
+ * RA.isRegExp(new RegExp()); //=> true
+ * RA.isRegExp(/(?:)/); //=> true
+ * RA.isRegExp(1); //=> false
+ */
+var isRegExp = (0, _ramda.curryN)(1, (0, _ramda.pipe)(_ramda.type, (0, _ramda.identical)('RegExp')));
+var _default = isRegExp;
+exports["default"] = _default;

package/lib/isSafeInteger.js

@@ -0,0 +1,46 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.isSafeIntegerPonyfill = void 0;
+
+var _ramda = require("ramda");
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+var _Number = _interopRequireDefault(require("./internal/ponyfills/Number.isSafeInteger"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var isSafeIntegerPonyfill = (0, _ramda.curryN)(1, _Number["default"]);
+/**
+ * Checks whether the passed value is a safe `integer`.
+ *
+ * @func isSafeInteger
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @example
+ *
+ * RA.isSafeInteger(3); //=> true
+ * RA.isSafeInteger(Math.pow(2, 53)) //=> false
+ * RA.isSafeInteger(Math.pow(2, 53) - 1); //=> true
+ * RA.isSafeInteger(NaN); //=> false
+ * RA.isSafeInteger(Infinity); //=> false
+ * RA.isSafeInteger('3') //=> false
+ * RA.isSafeInteger(3.1); //=> false
+ * RA.isSafeInteger(3.0); //=> true
+ * RA.isSafeInteger('string'); //=> false
+ * RA.isSafeInteger(null); //=> false
+ * RA.isSafeInteger(undefined); //=> false
+ * RA.isSafeInteger({}); //=> false
+ * RA.isSafeInteger(() => { }); //=> false
+ * RA.isSafeInteger(true); //=> false
+ */
+
+exports.isSafeIntegerPonyfill = isSafeIntegerPonyfill;
+var isSafeInteger = (0, _isFunction["default"])(Number.isSafeInteger) ? (0, _ramda.curryN)(1, (0, _ramda.bind)(Number.isSafeInteger, Number)) : isSafeIntegerPonyfill;
+var _default = isSafeInteger;
+exports["default"] = _default;

package/lib/isSentinelValue.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isInteger = _interopRequireDefault(require("./isInteger32"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks whether the passed value is {@link https://github.com/getify/You-Dont-Know-JS/blob/9959fc904d584bbf0b02cf41c192f74ff4238581/types-grammar/ch4.md#the-curious-case-of-the-|a sentinel value}.
+ *
+ * @func isSentinelValue
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.33.0|v2.33.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @example
+ *
+ * RA.isSentinelValue(-1); //=> true
+ *
+ * RA.isSentinelValue('-1'); //=> false
+ * RA.isSentinelValue(1); //=> false
+ * RA.isSentinelValue([-1]); //=> false
+ */
+// eslint-disable-next-line no-bitwise
+var isSentinelValue = (0, _ramda.curryN)(1, function (val) {
+  return (0, _isInteger["default"])(val) && ~val === 0;
+});
+var _default = isSentinelValue;
+exports["default"] = _default;

package/lib/isSet.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Predicate for determining if a provided value is an instance of a Set.
+ *
+ * @func isSet
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isMap|isMap}}
+ * @example
+ *
+ * RA.isSet(new Map()); //=> false
+ * RA.isSet(new Set()); //=> true
+ * RA.isSet(new Set([1,2]); //=> true
+ * RA.isSet(new Object()); //=> false
+ */
+var isSet = (0, _ramda.curryN)(1, (0, _ramda.pipe)(_ramda.type, (0, _ramda.identical)('Set')));
+var _default = isSet;
+exports["default"] = _default;

package/lib/isSparseArray.js

@@ -0,0 +1,39 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isArray = _interopRequireDefault(require("./isArray"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if input value is a sparse Array.
+ * An array with at least one "empty slot" in it is often called a "sparse array."
+ * Empty slot doesn't mean that the slot contains `null` or `undefined` values,
+ * but rather that the slots don't exist.
+ *
+ * @func isSparseArray
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.20.0|v2.20.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} list The list to test
+ * @return {boolean}
+ * @see {@link https://github.com/getify/You-Dont-Know-JS/blob/f0d591b6502c080b92e18fc470432af8144db610/types%20%26%20grammar/ch3.md#array|Sparse Arrays}, {@link RA.isArray|isArray}
+ * @example
+ *
+ * RA.isSparseArray(new Array(3)); // => true
+ * RA.isSparseArray([1,,3]); // => true
+ *
+ * const list = [1, 2, 3];
+ * delete list[1];
+ * RA.isSparseArray(list); // => true
+ *
+ * RA.isSparseArray([1, 2, 3]); // => false
+ */
+var isSparseArray = (0, _ramda.both)(_isArray["default"], (0, _ramda.converge)((0, _ramda.complement)(_ramda.identical), [(0, _ramda.pipe)(_ramda.values, _ramda.length), _ramda.length]));
+var _default = isSparseArray;
+exports["default"] = _default;

package/lib/isString.js

@@ -0,0 +1,26 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Checks if input value is `String`.
+ *
+ * @func isString
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.4.0|v0.4.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotString|isNotString}
+ * @example
+ *
+ * RA.isString('abc'); //=> true
+ * RA.isString(1); //=> false
+ */
+var isString = (0, _ramda.curryN)(1, (0, _ramda.pipe)(_ramda.type, (0, _ramda.identical)('String')));
+var _default = isString;
+exports["default"] = _default;

package/lib/isSymbol.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+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); }
+
+/**
+ * Checks if input value is a Symbol.
+ *
+ * @func isSymbol
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol|MDN Symbol}
+ * @example
+ *
+ * RA.isSymbol(Symbol('1')); //=> true
+ * RA.isSymbol(Symbol(1)); //=> true
+ * RA.isSymbol('string'); //=> false
+ * RA.isSymbol(undefined); //=> false
+ * RA.isSymbol(null); //=> false
+ */
+var isSymbol = (0, _ramda.curryN)(1, function (val) {
+  return _typeof(val) === 'symbol' || _typeof(val) === 'object' && (0, _ramda.type)(val) === 'Symbol';
+});
+var _default = isSymbol;
+exports["default"] = _default;

package/lib/isThenable.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if input value is a `thenable`.
+ * `thenable` is an object or function that defines a `then` method.
+ *
+ * @func isThenable
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.1.0|v2.1.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isPromise|isPromise}
+ * @example
+ *
+ * RA.isThenable(null); // => false
+ * RA.isThenable(undefined); // => false
+ * RA.isThenable([]); // => false
+ * RA.isThenable(Promise.resolve()); // => true
+ * RA.isThenable(Promise.reject()); // => true
+ * RA.isThenable({ then: () => 1 }); // => true
+ */
+var isThenable = (0, _ramda.pathSatisfies)(_isFunction["default"], ['then']);
+var _default = isThenable;
+exports["default"] = _default;

package/lib/isTrue.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Checks if input value is the Boolean primitive `true`. Will return false for Boolean objects
+ * created using the `Boolean` function as a constructor.
+ *
+ * @func isTrue
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isFalse|isFalse}, {@link RA.isTruthy|isTruthy}, {@link RA.isFalsy|isFalsy}
+ * @example
+ *
+ * RA.isTrue(true); // => true
+ * RA.isTrue(Boolean(true)); // => true
+ * RA.isTrue(false); // => false
+ * RA.isTrue(1); // => false
+ * RA.isTrue('true'); // => false
+ * RA.isTrue(new Boolean(true)); // => false
+ */
+var isTrue = (0, _ramda.identical)(true);
+var _default = isTrue;
+exports["default"] = _default;

package/lib/isTruthy.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * In JavaScript, a `truthy` value is a value that is considered true
+ * when evaluated in a Boolean context. All values are truthy unless
+ * they are defined as falsy (i.e., except for `false`, `0`, `""`, `null`, `undefined`, and `NaN`).
+ *
+ * @func isTruthy
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.2.0|v2.2.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Glossary/Truthy|truthy}, {@link RA.isFalsy|isFalsy}
+ * @example
+ *
+ * RA.isTruthy({}); // => true
+ * RA.isTruthy([]); // => true
+ * RA.isTruthy(42); // => true
+ * RA.isTruthy(3.14); // => true
+ * RA.isTruthy('foo'); // => true
+ * RA.isTruthy(new Date()); // => true
+ * RA.isTruthy(Infinity); // => true
+ */
+var isTruthy = (0, _ramda.curryN)(1, Boolean);
+var _default = isTruthy;
+exports["default"] = _default;

package/lib/isUndefined.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _stubUndefined = _interopRequireDefault(require("./stubUndefined"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if input value is `undefined`.
+ *
+ * @func isUndefined
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.0.1|v0.0.1}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotUndefined|isNotUndefined}
+ * @example
+ *
+ * RA.isUndefined(1); //=> false
+ * RA.isUndefined(undefined); //=> true
+ * RA.isUndefined(null); //=> false
+ */
+var isUndefined = (0, _ramda.equals)((0, _stubUndefined["default"])());
+var _default = isUndefined;
+exports["default"] = _default;

package/lib/isValidDate.js

@@ -0,0 +1,36 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isDate = _interopRequireDefault(require("./isDate"));
+
+var _isNotNaN = _interopRequireDefault(require("./isNotNaN"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/* eslint-disable max-len */
+
+/**
+ * Checks if value is valid `Date` object.
+ *
+ * @func isValidDate
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.8.0|v1.8.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isDate|isDate}, {@link RA.isNotDate|isNotDate}, {@link RA.isNotValidDate|isNotValidDate}
+ * @example
+ *
+ * RA.isValidDate(new Date()); //=> true
+ * RA.isValidDate(new Date('a')); //=> false
+ */
+
+/* eslint-enable max-len */
+var isValidDate = (0, _ramda.curryN)(1, (0, _ramda.both)(_isDate["default"], (0, _ramda.pipe)((0, _ramda.invoker)(0, 'getTime'), _isNotNaN["default"])));
+var _default = isValidDate;
+exports["default"] = _default;

package/lib/isValidNumber.js

@@ -0,0 +1,36 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isFloat = _interopRequireDefault(require("./isFloat"));
+
+var _isInteger = _interopRequireDefault(require("./isInteger"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if value is a valid `Number`. A valid `Number` is a number that is not `NaN`, `Infinity`
+ * or `-Infinity`.
+ *
+ * @func isValidNumber
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.2.0|v2.2.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotValidNumber|isNotValidNumber}
+ * @example
+ *
+ * RA.isValidNumber(1); //=> true
+ * RA.isValidNumber(''); //=> false
+ * RA.isValidNumber(NaN); //=> false
+ * RA.isValidNumber(Infinity); //=> false
+ * RA.isValidNumber(-Infinity); //=> false
+ */
+var isValidNumber = (0, _ramda.curryN)(1, (0, _ramda.either)(_isInteger["default"], _isFloat["default"]));
+var _default = isValidNumber;
+exports["default"] = _default;

package/lib/lastP.js

@@ -0,0 +1,76 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _allP = _interopRequireDefault(require("./allP"));
+
+var _lengthEq = _interopRequireDefault(require("./lengthEq"));
+
+var _lengthGte = _interopRequireDefault(require("./lengthGte"));
+
+var _rejectP = _interopRequireDefault(require("./rejectP"));
+
+var _resolveP = _interopRequireDefault(require("./resolveP"));
+
+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; }
+
+/**
+ * Returns a promise that is fulfilled by the last given promise to be fulfilled,
+ * or rejected with an array of rejection reasons if all of the given promises are rejected.
+ *
+ * @func lastP
+ * @memberOf RA
+ * @category Function
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.23.0|v2.23.0}
+ * @sig [Promise a] -> Promise a
+ * @param {Iterable.<*>} iterable An iterable object such as an Array or String
+ * @return {Promise} A promise that is fulfilled by the last given promise to be fulfilled, or rejected with an array of rejection reasons if all of the given promises are rejected.
+ * @see {@link RA.anyP|anyP}
+ * @example
+ *
+ * const delayP = timeout => new Promise(resolve => setTimeout(() => resolve(timeout), timeout));
+ * delayP.reject = timeout => new Promise((resolve, reject) => setTimeout(() => reject(timeout), timeout));
+ * RA.lastP([
+ *   1,
+ *   delayP(10),
+ *   delayP(100),
+ *   delayP.reject(1000),
+ * ]); //=> Promise(100)
+ */
+var lastP = (0, _ramda.curryN)(1, function (iterable) {
+  var fulfilled = [];
+  var rejected = [];
+  var onFulfill = (0, _ramda.bind)(fulfilled.push, fulfilled);
+  var onReject = (0, _ramda.bind)(rejected.push, rejected);
+  var listOfPromises = (0, _ramda.map)(function (p) {
+    return (0, _resolveP["default"])(p).then(onFulfill)["catch"](onReject);
+  }, _toConsumableArray(iterable));
+  return (0, _allP["default"])(listOfPromises).then(function () {
+    if ((0, _lengthEq["default"])(0, fulfilled) && (0, _lengthEq["default"])(0, rejected)) {
+      return undefined;
+    }
+
+    if ((0, _lengthGte["default"])(1, fulfilled)) {
+      return (0, _ramda.last)(fulfilled);
+    }
+
+    return (0, _rejectP["default"])(rejected);
+  });
+});
+var _default = lastP;
+exports["default"] = _default;

package/lib/lengthEq.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 equal to `valueLength`.
+ *
+ * @func lengthEq
+ * @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.lengthNotEq|lengthNotEq}, {@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.lengthEq(3, [1,2,3]); //=> true
+ * RA.lengthEq(3, [1,2,3,4]); //=> false
+ */
+var lengthEq = (0, _compareLength["default"])(_ramda.equals);
+var _default = lengthEq;
+exports["default"] = _default;

package/lib/lengthGt.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 greater than `valueLength`.
+ *
+ * @func lengthGt
+ * @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.lengthLte|lengthLte}, {@link RA.lengthGte|lengthGte}, {@link http://ramdajs.com/docs/#gt|gt},  {@link http://ramdajs.com/docs/#length|length}
+ * @example
+ *
+ * RA.lengthGt(3, [1,2,3,4]); //=> true
+ * RA.lengthGt(3, [1,2,3]); //=> false
+ */
+var lengthGt = (0, _compareLength["default"])((0, _ramda.flip)(_ramda.gt));
+var _default = lengthGt;
+exports["default"] = _default;

package/lib/lengthGte.js

@@ -0,0 +1,33 @@
+"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 greater than or equal to
+ * `valueLength`.
+ *
+ * @func lengthGte
+ * @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.lengthLte|lengthLte}, {@link http://ramdajs.com/docs/#gte|gte}, {@link http://ramdajs.com/docs/#length|length}
+ * @example
+ *
+ * RA.lengthGte(3, [1,2,3,4]); //=> true
+ * RA.lengthGte(3, [1,2,3]); //=> true
+ * RA.lengthGte(3, [1,2]); //=> false
+ */
+var lengthGte = (0, _compareLength["default"])((0, _ramda.flip)(_ramda.gte));
+var _default = lengthGte;
+exports["default"] = _default;

package/lib/lengthLt.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 less than `valueLength`.
+ *
+ * @func lengthLt
+ * @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.lengthGt|lengthGt}, {@link RA.lengthLte|lengthLte}, {@link RA.lengthGte|lengthGte}, {@link http://ramdajs.com/docs/#lt|lt}, {@link http://ramdajs.com/docs/#length|length}
+ * @example
+ *
+ * RA.lengthLt(3, [1,2]); //=> true
+ * RA.lengthLt(3, [1,2,3]); //=> false
+ */
+var lengthLt = (0, _compareLength["default"])((0, _ramda.flip)(_ramda.lt));
+var _default = lengthLt;
+exports["default"] = _default;