ramda-adjunct 2.34.0

package/lib/concatAll.js

@@ -0,0 +1,40 @@
+"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 }; }
+
+var leftIdentitySemigroup = {
+  concat: _ramda.identity
+};
+/**
+ * Returns the result of concatenating the given lists or strings.
+ * Note: RA.concatAll expects all elements to be of the same type. It will throw an error if you concat an Array with a non-Array value.
+ * Dispatches to the concat method of the preceding element, if present. Can also concatenate multiple elements of a [fantasy-land compatible semigroup](https://github.com/fantasyland/fantasy-land#semigroup).
+ * Returns undefined if empty array was passed.
+ *
+ * @func concatAll
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}
+ * @category List
+ * @sig [[a]] -> [a] | Undefined
+ * @sig [String] -> String | Undefined
+ * @sig Semigroup s => Foldable s f => f -> s | Undefined
+ * @param {Array.<Array|string>} list List containing elements that will be concatenated
+ * @return {Array|string|undefined} Concatenated elements
+ * @see {@link http://ramdajs.com/docs/#concat|R.concat}, {@link RA.concatRight|concatRight}, {@link http://ramdajs.com/docs/#unnest|R.unnest}, {@link http://ramdajs.com/docs/#join|R.join}
+ * @example
+ *
+ * concatAll([[1], [2], [3]]); //=> [1, 2, 3]
+ * concatAll(['1', '2', '3']); //=> '123'
+ * concatAll([]); //=> undefined;
+ */
+
+var concatAll = (0, _ramda.pipe)((0, _ramda.reduce)(_ramda.concat, leftIdentitySemigroup), (0, _ramda.when)((0, _ramda.identical)(leftIdentitySemigroup), _stubUndefined["default"]));
+var _default = concatAll;
+exports["default"] = _default;

package/lib/concatRight.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns the result of concatenating the given lists or strings.
+ *
+ * Note: R.concat expects both arguments to be of the same type, unlike
+ * the native Array.prototype.concat method.
+ * It will throw an error if you concat an Array with a non-Array value.
+ * Dispatches to the concat method of the second argument, if present.
+ *
+ * @func concatRight
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.11.0|v1.11.0}
+ * @category List
+ * @sig [a] -> [a] -> [a]
+ * @sig String -> String -> String
+ * @param {Array|String} firstList The first list
+ * @param {Array|String} secondList The second list
+ * @return {Array|String} A list consisting of the elements of `secondList`
+ * followed by the elements of `firstList`.
+ * @see {@link http://ramdajs.com/docs/#concat|R.concat}
+ * @example
+ *
+ * RA.concatRight('ABC', 'DEF'); //=> 'DEFABC'
+ * RA.concatRight([4, 5, 6], [1, 2, 3]); //=> [1, 2, 3, 4, 5, 6]
+ * RA.concatRight([], []); //=> []
+ */
+var concatRight = (0, _ramda.flip)(_ramda.concat);
+var _default = concatRight;
+exports["default"] = _default;

package/lib/contained.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns true if the specified value is equal, in R.equals terms,
+ * to at least one element of the given list or false otherwise.
+ * Given list can be a string.
+ *
+ * Like {@link http://ramdajs.com/docs/#contains|R.contains} but with argument order reversed.
+ *
+ * @func contained
+ * @aliases included
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
+ * @deprecated since v2.12.0; please use RA.included alias
+ * @category List
+ * @sig [a] -> a -> Boolean
+ * @param {Array|String} list The list to consider
+ * @param {*} a The item to compare against
+ * @return {boolean} Returns Boolean `true` if an equivalent item is in the list or `false` otherwise
+ * @see {@link http://ramdajs.com/docs/#contains|R.contains}
+ * @example
+ *
+ * RA.contained([1, 2, 3], 3); //=> true
+ * RA.contained([1, 2, 3], 4); //=> false
+ * RA.contained([{ name: 'Fred' }], { name: 'Fred' }); //=> true
+ * RA.contained([[42]], [42]); //=> true
+ */
+var contained = (0, _ramda.flip)(_ramda.contains);
+var _default = contained;
+exports["default"] = _default;

package/lib/curryRight.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _curryRightN = _interopRequireDefault(require("./curryRightN"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Returns a curried equivalent of the provided function.
+ * This function is like curry, except that the provided arguments order is reversed.
+ *
+ * @func curryRight
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.12.0|v1.12.0}
+ * @category Function
+ * @sig (* -> a) -> (* -> a)
+ * @param {Function} fn The function to curry
+ * @return {Function}  A new, curried function
+ * @see {@link http://ramdajs.com/docs/#curry|R.curry}, {@link RA.curryRightN|curryRightN}
+ * @example
+ *
+ * const concatStrings = (a, b, c) => a + b + c;
+ * const concatStringsCurried = RA.curryRight(concatStrings);
+ *
+ * concatStringCurried('a')('b')('c'); // => 'cba'
+ */
+var curryRight = (0, _ramda.converge)(_curryRightN["default"], [_ramda.length, _ramda.identity]);
+var _default = curryRight;
+exports["default"] = _default;

package/lib/curryRightN.js

@@ -0,0 +1,38 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns a curried equivalent of the provided function, with the specified arity.
+ * This function is like curryN, except that the provided arguments order is reversed.
+ *
+ * @func curryRightN
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.12.0|v1.12.0}
+ * @category Function
+ * @sig Number -> (* -> a) -> (* -> a)
+ * @param {number} length The arity for the returned function
+ * @param {Function} fn The function to curry
+ * @return {Function}  A new, curried function
+ * @see {@link http://ramdajs.com/docs/#curryN|R.curryN}, {@link RA.curryRight|curryRight}
+ * @example
+ *
+ * const concatStrings = (a, b, c) => a + b + c;
+ * const concatStringsCurried = RA.curryRightN(3, concatStrings);
+ *
+ * concatStringCurried('a')('b')('c'); // => 'cba'
+ */
+var curryRightN = (0, _ramda.curryN)(2, function (arity, fn) {
+  return (0, _ramda.curryN)(arity, function wrapper() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return fn.apply(this, (0, _ramda.reverse)(args));
+  });
+});
+var _default = curryRightN;
+exports["default"] = _default;

package/lib/defaultWhen.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns the second argument if predicate function returns `true`,
+ * otherwise the third argument is returned.
+ *
+ * @func defaultWhen
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.2.0|v2.2.0}
+ * @category Logic
+ * @sig  (a -> Boolean) -> b -> a -> a | b
+ * @param {!function} predicate The predicate function
+ * @param {*} defaultVal The default value
+ * @param {*} val `val` will be returned instead of `defaultVal` if predicate returns false
+ * @return {*} The `val` if predicate returns `false`, otherwise the default value
+ * @see {@link http://ramdajs.com/docs/#defaultTo|R.defaultTo}
+ * @example
+ *
+ * RA.defaultWhen(RA.isNull, 1, null); // => 1
+ * RA.defaultWhen(RA.isNull, 1, 2); // => 2
+ */
+var defaultWhen = (0, _ramda.curry)(function (predicate, defaultVal, val) {
+  return predicate(val) ? defaultVal : val;
+});
+var _default = defaultWhen;
+exports["default"] = _default;

package/lib/delayP.js

@@ -0,0 +1,54 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isNonNegative = _interopRequireDefault(require("./isNonNegative"));
+
+var _isInteger = _interopRequireDefault(require("./isInteger"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Creates a promise which resolves/rejects after the specified milliseconds.
+ *
+ * @func delayP
+ * @memberOf RA
+ * @category Function
+ * @sig Number -> Promise Undefined
+ * @sig {timeout: Number, value: a} -> Promise a
+ * @param {number|Object} milliseconds number of milliseconds or options object
+ * @return {Promise} A Promise that is resolved/rejected with the given value (if provided) after the specified delay
+ * @example
+ *
+ * RA.delayP(200); //=> Promise(undefined)
+ * RA.delayP({ timeout: 1000, value: 'hello world' }); //=> Promise('hello world')
+ * RA.delayP.reject(100); //=> Promise(undefined)
+ * RA.delayP.reject({ timeout: 100, value: new Error('error') }); //=> Promise(Error('error'))
+ */
+var makeDelay = (0, _ramda.curry)(function (settleFnPicker, opts) {
+  var timeout;
+  var value;
+
+  if ((0, _isInteger["default"])(opts) && (0, _isNonNegative["default"])(opts)) {
+    timeout = opts;
+  } else {
+    timeout = (0, _ramda.propOr)(0, 'timeout', opts);
+    value = (0, _ramda.propOr)(value, 'value', opts);
+  }
+
+  return new Promise(function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var settleFn = settleFnPicker(args);
+    setTimeout((0, _ramda.partial)(settleFn, [value]), timeout);
+  });
+});
+var delayP = makeDelay((0, _ramda.nth)(0));
+delayP.reject = makeDelay((0, _ramda.nth)(1));
+var _default = delayP;
+exports["default"] = _default;

package/lib/dispatch.js

@@ -0,0 +1,50 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isNotNil = _interopRequireDefault(require("./isNotNil"));
+
+var _isNonEmptyArray = _interopRequireDefault(require("./isNonEmptyArray"));
+
+var _stubUndefined = _interopRequireDefault(require("./stubUndefined"));
+
+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 byArity = (0, _ramda.comparator)(function (a, b) {
+  return a.length > b.length;
+});
+var getMaxArity = (0, _ramda.pipe)((0, _ramda.sort)(byArity), _ramda.head, (0, _ramda.prop)('length'));
+var iteratorFn = (0, _ramda.curry)(function (args, accumulator, fn) {
+  var result = fn.apply(void 0, _toConsumableArray(args));
+  return (0, _isNotNil["default"])(result) ? (0, _ramda.reduced)(result) : accumulator;
+});
+
+var dispatchImpl = function dispatchImpl(functions) {
+  var arity = getMaxArity(functions);
+  return (0, _ramda.curryN)(arity, function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return (0, _ramda.reduce)(iteratorFn(args), undefined, functions);
+  });
+};
+
+var dispatch = (0, _ramda.ifElse)(_isNonEmptyArray["default"], dispatchImpl, _stubUndefined["default"]);
+var _default = dispatch;
+exports["default"] = _default;

package/lib/divideNum.js

@@ -0,0 +1,25 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Divides two numbers, where the second number is divided by the first number.
+ *
+ * @func divideNum
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category Math
+ * @sig Number -> Number -> Number
+ * @param {number} divisor the number to divide by
+ * @param {number} dividend the number to divide
+ * @return {number} A number representing the quotient of dividing the dividend by the divisor
+ * @example
+ *
+ * RA.divideNum(2, 1); //=> 0.5
+ */
+var divideNum = (0, _ramda.flip)(_ramda.divide);
+var _default = divideNum;
+exports["default"] = _default;

package/lib/dropArgs.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Accepts a function with any arity and returns a function with arity of zero.
+ * The returned function ignores any arguments supplied to it.
+ *
+ * @func dropArgs
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.10.0|v2.10.0}
+ * @category Logic
+ * @sig (...a -> b)-> () -> b
+ * @param {Function} fn The function with any arity
+ * @return {Function} Returns function with arity of zero
+ * @see {@link http://ramdajs.com/docs/#nAry|R.nAry}
+ * @example
+ *
+ * const fn = (a = 1, b = 2) => a + b;
+ *
+ * RA.dropArgs(fn)('ignore1', 'ignore2'); //=> 3
+ */
+var dropArgs = (0, _ramda.nAry)(0);
+var _default = dropArgs;
+exports["default"] = _default;

package/lib/ensureArray.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isNotArray = _interopRequireDefault(require("./isNotArray"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Returns a singleton array containing the value provided.
+ * If value is already an array, it is returned as is.
+ *
+ * @func ensureArray
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}
+ * @category List
+ * @sig a | [a] -> [a]
+ * @param {*|Array} val the value ensure as Array
+ * @return {Array}
+ * @see {@link http://ramdajs.com/docs/#of|R.of}
+ * @example
+ *
+ * RA.ensureArray(42); //=> [42]
+ * RA.ensureArray([42]); //=> [42]
+ */
+var ensureArray = (0, _ramda.when)(_isNotArray["default"], _ramda.of);
+var _default = ensureArray;
+exports["default"] = _default;

package/lib/escapeRegExp.js

@@ -0,0 +1,29 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isString = _interopRequireDefault(require("./isString"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Escapes the RegExp special characters.
+ *
+ * @func escapeRegExp
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.21.0|v2.21.0}
+ * @category String
+ * @sig String -> String
+ * @param {string} val the value to escape
+ * @return {string}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping|MDN Regular Expressions Escaping}
+ * @example
+ *
+ * RA.escapeRegExp('[ramda-adjunct](https://github.com/char0n/ramda-adjunct)'); //=> '\[ramda\-adjunct\]\(https://github\.com/char0n/ramda\-adjunct\)'
+ */
+var escapeRegExp = (0, _ramda.when)(_isString["default"], (0, _ramda.replace)(/[.*+?^${}()|[\]\\-]/g, '\\$&'));
+var _default = escapeRegExp;
+exports["default"] = _default;