ramda-adjunct 3.2.0 → 3.4.0

package/es/Y.js

@@ -1,4 +1,5 @@
 import { curryN } from 'ramda';
+
 /**
  * Y-combinator
  *

package/es/allEqual.js

@@ -1,5 +1,7 @@
 import { pipe, uniq, curryN } from 'ramda';
-import lengthLte from './lengthLte'; // Original idea for this function was conceived by https://github.com/jackmellis
+import lengthLte from './lengthLte';
+
+// Original idea for this function was conceived by https://github.com/jackmellis
 // in https://github.com/char0n/ramda-adjunct/pull/513.
 
 /**
@@ -20,6 +22,5 @@ import lengthLte from './lengthLte'; // Original idea for this function was conc
  * RA.allEqual([]); //=> true
  *
  */
-
 var allEqual = curryN(1, pipe(uniq, lengthLte(1)));
 export default allEqual;

package/es/allEqualTo.js

@@ -1,4 +1,5 @@
 import { all, equals, curry } from 'ramda';
+
 /**
  * Returns true if all items in the list are equivalent to user provided value using `R.equals` for equality comparisons.
  *
@@ -19,7 +20,6 @@ import { all, equals, curry } from 'ramda';
  * RA.allEqualTo(1, []); //=> true
  *
  */
-
 var allEqualTo = curry(function (val, list) {
   return all(equals(val), list);
 });

package/es/allIdentical.js

@@ -1,5 +1,6 @@
 import { uniqWith, identical, pipe, curryN } from 'ramda';
 import lengthLte from './lengthLte';
+
 /**
  * Returns true if all items in the list are equivalent using `R.identical` for equality comparisons.
  *
@@ -19,6 +20,5 @@ import lengthLte from './lengthLte';
  * RA.allIdentical([ {}, {} ]); //=> false
  * RA.allIdentical([ () => {}, () => {} ]); //=> false
  */
-
 var allIdentical = curryN(1, pipe(uniqWith(identical), lengthLte(1)));
 export default allIdentical;

package/es/allIdenticalTo.js

@@ -1,4 +1,5 @@
 import { curry, identical, all } from 'ramda';
+
 /**
  * Returns true if all items in the list are equivalent to user provided value using `R.identical` for equality comparisons.
  *
@@ -19,7 +20,6 @@ import { curry, identical, all } from 'ramda';
  * RA.allIdenticalTo({}, [ {}, {} ]); //=> false
  *
  */
-
 var allIdenticalTo = curry(function (val, list) {
   return all(identical(val), list);
 });

package/es/allP.js

@@ -1,4 +1,5 @@
 import { bind, curryN } from 'ramda';
+
 /**
  * Composable shortcut for `Promise.all`.
  *
@@ -21,6 +22,5 @@ import { bind, curryN } from 'ramda';
  * RA.allP([Promise.resolve(1), Promise.resolve(2)]); //=> Promise([1, 2])
  * RA.allP([1, Promise.reject(2)]); //=> Promise(2)
  */
-
 var allP = curryN(1, bind(Promise.all, Promise));
 export default allP;

package/es/allSettledP.js

@@ -2,6 +2,7 @@ import { bind, curryN } from 'ramda';
 import isFunction from './isFunction';
 import ponyfill from './internal/ponyfills/Promise.allSettled';
 export var allSettledPPonyfill = curryN(1, ponyfill);
+
 /**
  * Returns a promise that is fulfilled with an array of promise state snapshots,
  * but only after all the original promises have settled, i.e. become either fulfilled or rejected.
@@ -24,6 +25,5 @@ export var allSettledPPonyfill = curryN(1, ponyfill);
  *   Promise.reject(3),
  * ]); //=> Promise([{ status: 'fulfilled', value: 1 }, { status: 'fulfilled', value: 2 }, { status: 'rejected', reason: 3 }])
  */
-
 var allSettledP = isFunction(Promise.allSettled) ? curryN(1, bind(Promise.allSettled, Promise)) : allSettledPPonyfill;
 export default allSettledP;

package/es/allUnique.js

@@ -1,5 +1,6 @@
 import { converge, length, uniq } from 'ramda';
 import lengthEq from './lengthEq';
+
 /**
  * Returns true if all items in the list are unique. `R.equals` is used to determine equality.
  *
@@ -18,6 +19,5 @@ import lengthEq from './lengthEq';
  * RA.allUnique([]); //=> true
  *
  */
-
 var allUnique = converge(lengthEq, [length, uniq]);
 export default allUnique;

package/es/anyP.js

@@ -3,6 +3,7 @@ import isFunction from './isFunction';
 import ponyfill, { AggregatedError } from './internal/ponyfills/Promise.any';
 export var anyPPonyfill = curryN(1, ponyfill);
 export { AggregatedError };
+
 /**
  * Returns a promise that is fulfilled by the first given promise to be fulfilled,
  * or rejected with an array of rejection reasons if all of the given promises are rejected.
@@ -23,6 +24,5 @@ export { AggregatedError };
  *   Promise.reject(3),
  * ]); //=> Promise(1)
  */
-
 var anyP = isFunction(Promise.any) ? curryN(1, bind(Promise.any, Promise)) : anyPPonyfill;
 export default anyP;

package/es/appendFlipped.js

@@ -1,4 +1,5 @@
 import { append, flip } from 'ramda';
+
 /**
  * Returns a new list containing the contents of the given list, followed by the given element.
  * Like {@link http://ramdajs.com/docs/#append|R.append} but with argument order reversed.
@@ -18,6 +19,5 @@ import { append, flip } from 'ramda';
  * RA.appendFlipped([], 'tests'); //=> ['tests']
  * RA.appendFlipped(['write', 'more'], ['tests']); //=> ['write', 'more', ['tests']]
  */
-
 var appendFlipped = flip(append);
 export default appendFlipped;

package/es/argsPass.js

@@ -1,6 +1,7 @@
 import { useWith, curry, compose } from 'ramda';
 import list from './list';
 import isTruthy from './isTruthy';
+
 /**
  * Takes a combining predicate and a list of functions and returns a function which will map the
  * arguments it receives to the list of functions and returns the result of passing the values
@@ -31,7 +32,6 @@ import isTruthy from './isTruthy';
  * RA.argsPass(R.none, [RA.isArray, RA.isBoolean, RA.isString])({}, 1, false) //=> true
  * RA.argsPass(R.none, [RA.isArray, RA.isBoolean, RA.isString])({}, 1, 'abc') //=> false
  */
-
 var argsPass = curry(function (combiningPredicate, predicates) {
   return useWith(compose(combiningPredicate(isTruthy), list), predicates);
 });

package/es/async.js

@@ -1,6 +1,7 @@
 import { curryN, bind } from 'ramda';
 import resolveP from './resolveP';
 import rejectP from './rejectP';
+
 /**
  * Takes a generator function and returns an async function.
  * The async function returned is a curried function whose arity matches that of the generator function.
@@ -27,11 +28,9 @@ import rejectP from './rejectP';
  * asyncFn(1, 2); //=> Promise(3)
  *
  */
-
 var async = curryN(1, function (generatorFn) {
   function asyncWrapper() {
     var iterator = bind(generatorFn, this).apply(void 0, arguments);
-
     var handle = function handle(result) {
       var resolved = resolveP(result.value);
       return result.done ? resolved : resolved.then(function (value) {
@@ -40,18 +39,15 @@ var async = curryN(1, function (generatorFn) {
         return handle(iterator["throw"](error));
       });
     };
-
     try {
       return handle(iterator.next());
     } catch (error) {
       return rejectP(error);
     }
   }
-
   if (generatorFn.length > 0) {
     return curryN(generatorFn.length, asyncWrapper);
   }
-
   return asyncWrapper;
 });
 export default async;

package/es/cata.js

@@ -1,5 +1,6 @@
 import { curry } from 'ramda';
 import isFunction from './isFunction';
+
 /**
  * The catamorphism is a way of folding a type into a value.
  *
@@ -52,7 +53,6 @@ import isFunction from './isFunction';
  * RA.cata(identity, identity, maybeSome); //=> 1
  * RA.cata(identity, identity, maybeNothing); //=> undefined
  */
-
 var catamorphism = curry(function (leftFn, rightFn, catamorphicObj) {
   // folktale support
   if (isFunction(catamorphicObj.matchWith)) {
@@ -85,17 +85,14 @@ var catamorphism = curry(function (leftFn, rightFn, catamorphicObj) {
       }
     });
   }
-
   if (isFunction(catamorphicObj.cata)) {
     return catamorphicObj.cata(leftFn, rightFn);
   }
-
   if (isFunction(catamorphicObj.getOrElse)) {
     var elseValue = "RA.cata".concat(Math.random());
     var value = catamorphicObj.getOrElse(elseValue);
     return value === elseValue ? leftFn() : rightFn(value);
   }
-
   return catamorphicObj.either(leftFn, rightFn);
 });
 export default catamorphism;

package/es/catchP.js

@@ -1,4 +1,5 @@
 import { invoker } from 'ramda';
+
 /**
  * Composable shortcut for `Promise.catch`.
  * The catchP function returns a Promise. It takes two arguments: a callback function for the failure of the Promise
@@ -19,6 +20,5 @@ import { invoker } from 'ramda';
  * RA.catchP(() => 'b', Promise.resolve('a')); //=> Promise('a')
  * RA.catchP(() => 'b', Promise.reject('a')); //=> Promise('b')
  */
-
 var catchP = invoker(1, 'catch');
 export default catchP;

package/es/ceil.js

@@ -1,4 +1,5 @@
 import { bind, curryN } from 'ramda';
+
 /**
  * Returns the smallest integer greater than or equal to a given number.
  *

package/es/compact.js

@@ -1,5 +1,6 @@
 import { reject } from 'ramda';
 import isFalsy from './isFalsy';
+
 /**
  * Creates an array with all falsy values removed.
  * The values false, null, 0, "", undefined, and NaN are falsy.
@@ -16,6 +17,5 @@ import isFalsy from './isFalsy';
  *
  * RA.compact([0, 1, false, 2, '', 3]); //=> [1, 2, 3]
  */
-
 var compact = reject(isFalsy);
 export default compact;

package/es/concatAll.js

@@ -3,6 +3,7 @@ import stubUndefined from './stubUndefined';
 var leftIdentitySemigroup = {
   concat: 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.
@@ -25,6 +26,5 @@ var leftIdentitySemigroup = {
  * concatAll(['1', '2', '3']); //=> '123'
  * concatAll([]); //=> undefined;
  */
-
 var concatAll = pipe(reduce(concat, leftIdentitySemigroup), when(identical(leftIdentitySemigroup), stubUndefined));
 export default concatAll;

package/es/concatRight.js

@@ -1,4 +1,5 @@
 import { concat, flip } from 'ramda';
+
 /**
  * Returns the result of concatenating the given lists or strings.
  *
@@ -24,6 +25,5 @@ import { concat, flip } from 'ramda';
  * RA.concatRight([4, 5, 6], [1, 2, 3]); //=> [1, 2, 3, 4, 5, 6]
  * RA.concatRight([], []); //=> []
  */
-
 var concatRight = flip(concat);
 export default concatRight;

package/es/copyKeys.js

@@ -1,11 +1,12 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-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; }
-
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 import { curryN } from 'ramda';
 import renameKeys from './renameKeys';
+
 /**
  * Creates a new object with the own properties of the provided object, and the
  * keys copied according to the keysMap object as `{oldKey: newKey}`.
@@ -27,7 +28,6 @@ import renameKeys from './renameKeys';
  * copyKeys({ a: 'b' }, { a: true }); //=> { a: true, b: true }
  * copyKeys({ a: 'b' }, { a: true, b: false }); //=> { a: true, b: true }
  */
-
 var copyKeys = curryN(2, function (keysMap, obj) {
   return _objectSpread(_objectSpread({}, obj), renameKeys(keysMap, obj));
 });

package/es/curryRight.js

@@ -1,5 +1,6 @@
 import { converge, length, identity } from 'ramda';
 import curryRightN from './curryRightN';
+
 /**
  * Returns a curried equivalent of the provided function.
  * This function is like curry, except that the provided arguments order is reversed.
@@ -19,6 +20,5 @@ import curryRightN from './curryRightN';
  *
  * concatStringCurried('a')('b')('c'); // => 'cba'
  */
-
 var curryRight = converge(curryRightN, [length, identity]);
 export default curryRight;

package/es/curryRightN.js

@@ -1,4 +1,5 @@
 import { curryN, reverse } from '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.
@@ -19,13 +20,11 @@ import { curryN, reverse } from 'ramda';
  *
  * concatStringCurried('a')('b')('c'); // => 'cba'
  */
-
 var curryRightN = curryN(2, function (arity, fn) {
   return 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, reverse(args));
   });
 });

package/es/defaultWhen.js

@@ -1,4 +1,5 @@
 import { curry } from 'ramda';
+
 /**
  * Returns the second argument if predicate function returns `true`,
  * otherwise the third argument is returned.
@@ -18,7 +19,6 @@ import { curry } from 'ramda';
  * RA.defaultWhen(RA.isNull, 1, null); // => 1
  * RA.defaultWhen(RA.isNull, 1, 2); // => 2
  */
-
 var defaultWhen = curry(function (predicate, defaultVal, val) {
   return predicate(val) ? defaultVal : val;
 });

package/es/delayP.js

@@ -1,6 +1,7 @@
 import { curry, propOr, partial, nth } from 'ramda';
 import isNonNegative from './isNonNegative';
 import isInteger from './isInteger';
+
 /**
  * Creates a promise which resolves/rejects after the specified milliseconds.
  *
@@ -22,19 +23,16 @@ import isInteger from './isInteger';
 var makeDelay = curry(function (settleFnPicker, opts) {
   var timeout;
   var value;
-
   if (isInteger(opts) && isNonNegative(opts)) {
     timeout = opts;
   } else {
     timeout = propOr(0, 'timeout', opts);
     value = 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(partial(settleFn, [value]), timeout);
   });

package/es/dispatch.js

@@ -1,16 +1,11 @@
 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 { sort, comparator, prop, pipe, head, curryN, reduce, reduced, curry, ifElse } from 'ramda';
+
 /**
  * Can be used as a way to compose multiple invokers together to form polymorphic functions,
  * or functions that exhibit different behaviors based on their argument(s).
@@ -47,7 +42,6 @@ import { sort, comparator, prop, pipe, head, curryN, reduce, reduced, curry, ifE
  * ]);
  * fnSwitch(1); //=> 2
  */
-
 import isNotNil from './isNotNil';
 import isNonEmptyArray from './isNonEmptyArray';
 import stubUndefined from './stubUndefined';
@@ -59,17 +53,14 @@ var iteratorFn = curry(function (args, accumulator, fn) {
   var result = fn.apply(void 0, _toConsumableArray(args));
   return isNotNil(result) ? reduced(result) : accumulator;
 });
-
 var dispatchImpl = function dispatchImpl(functions) {
   var arity = getMaxArity(functions);
   return curryN(arity, function () {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-
     return reduce(iteratorFn(args), undefined, functions);
   });
 };
-
 var dispatch = ifElse(isNonEmptyArray, dispatchImpl, stubUndefined);
 export default dispatch;

package/es/divideNum.js

@@ -1,4 +1,5 @@
 import { divide, flip } from 'ramda';
+
 /**
  * Divides two numbers, where the second number is divided by the first number.
  *
@@ -14,6 +15,5 @@ import { divide, flip } from 'ramda';
  *
  * RA.divideNum(2, 1); //=> 0.5
  */
-
 var divideNum = flip(divide);
 export default divideNum;

package/es/dropArgs.js

@@ -1,4 +1,5 @@
 import { nAry } from 'ramda';
+
 /**
  * Accepts a function with any arity and returns a function with arity of zero.
  * The returned function ignores any arguments supplied to it.
@@ -17,6 +18,5 @@ import { nAry } from 'ramda';
  *
  * RA.dropArgs(fn)('ignore1', 'ignore2'); //=> 3
  */
-
 var dropArgs = nAry(0);
 export default dropArgs;

package/es/ensureArray.js

@@ -1,5 +1,6 @@
 import { when, of } from 'ramda';
 import isNotArray from './isNotArray';
+
 /**
  * Returns a singleton array containing the value provided.
  * If value is already an array, it is returned as is.
@@ -17,6 +18,5 @@ import isNotArray from './isNotArray';
  * RA.ensureArray(42); //=> [42]
  * RA.ensureArray([42]); //=> [42]
  */
-
 var ensureArray = when(isNotArray, of);
 export default ensureArray;

package/es/escapeRegExp.js

@@ -1,5 +1,6 @@
 import { when, replace } from 'ramda';
 import isString from './isString';
+
 /**
  * Escapes the RegExp special characters.
  *
@@ -15,6 +16,5 @@ import isString from './isString';
  *
  * RA.escapeRegExp('[ramda-adjunct](https://github.com/char0n/ramda-adjunct)'); //=> '\[ramda\-adjunct\]\(https://github\.com/char0n/ramda\-adjunct\)'
  */
-
 var escapeRegExp = when(isString, replace(/[.*+?^${}()|[\]\\-]/g, '\\$&'));
 export default escapeRegExp;