ramda-adjunct 5.0.0 → 5.0.1

package/babel.config.cjs

@@ -1,56 +0,0 @@
-'use strict';
-
-module.exports = {
-  env: {
-    commonjs: {
-      presets: [
-        [
-          '@babel/preset-env',
-          {
-            modules: 'commonjs',
-            forceAllTransforms: true,
-          },
-        ],
-      ],
-      plugins: [
-        [
-          '@babel/plugin-transform-modules-commonjs',
-          {
-            loose: true,
-          },
-        ],
-      ],
-    },
-    es: {
-      presets: [
-        [
-          '@babel/preset-env',
-          {
-            modules: false,
-            forceAllTransforms: true,
-          },
-        ],
-      ],
-    },
-    coverage: {
-      presets: [
-        [
-          '@babel/preset-env',
-          {
-            modules: 'commonjs',
-            forceAllTransforms: true,
-          },
-        ],
-      ],
-      plugins: [
-        'istanbul',
-        [
-          '@babel/plugin-transform-modules-commonjs',
-          {
-            loose: true,
-          },
-        ],
-      ],
-    },
-  },
-};

package/src/Y.js

@@ -1,32 +0,0 @@
-import { curryN } from 'ramda';
-
-/**
- * Y-combinator
- *
- * The Y combinator is an interesting function which only works with functional languages,
- * showing how recursion can still be done even without any variable or function declarations,
- * only functions and parameters
- *
- * @func Y
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.3.0|v2.3.0}
- * @category Function
- * @sig (a, ... -> b -> b) -> (a, ... -> b)
- * @param {Function} le Recursive function maker
- * @return {Function}
- * @see {@link http://kestas.kuliukas.com/YCombinatorExplained/|Y combinator explained}
- * @example
- *
- * const makeFact = givenFact => (n) => {
- *   if (n < 2) { return 1 }
- *   return n * givenFact(n - 1);
- * };
- *
- * const factorial = RA.Y(makeFact);
- *
- * factorial(5); //=> 120
- */
-
-const Y = curryN(1, (le) => ((f) => f(f))((g) => le((x) => g(g)(x))));
-
-export default Y;

package/src/allEqual.js

@@ -1,28 +0,0 @@
-import { pipe, uniq, curryN } from 'ramda';
-
-import lengthLte from './lengthLte.js';
-
-// Original idea for this function was conceived by https://github.com/jackmellis
-// in https://github.com/char0n/ramda-adjunct/pull/513.
-
-/**
- * Returns true if all items in the list are equivalent using `R.equals` for equality comparisons.
- *
- * @func allEqual
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.9.0|v2.9.0}
- * @category List
- * @sig [a] -> Boolean
- * @param {Array} list The list of values
- * @return {boolean}
- * @see {@link https://ramdajs.com/docs/#equals|equals}
- * @example
- *
- * RA.allEqual([ 1, 2, 3, 4 ]); //=> false
- * RA.allEqual([ 1, 1, 1, 1 ]); //=> true
- * RA.allEqual([]); //=> true
- *
- */
-const allEqual = curryN(1, pipe(uniq, lengthLte(1)));
-
-export default allEqual;

package/src/allEqualTo.js

@@ -1,25 +0,0 @@
-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.
- *
- * @func allEqualTo
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.11.0|v2.11.0}
- * @category List
- * @sig a -> [b] -> Boolean
- * @param {*} val User provided value to check the `list` against
- * @param {Array} list The list of values
- * @return {boolean}
- * @see {@link RA.allEqual|allEqual}, {@link https://ramdajs.com/docs/#equals|equals}
- * @example
- *
- * RA.allEqualTo(1, [ 1, 2, 3, 4 ]); //=> false
- * RA.allEqualTo(1, [ 1, 1, 1, 1 ]); //=> true
- * RA.allEqualTo({}, [ {}, {} ]); //=> true
- * RA.allEqualTo(1, []); //=> true
- *
- */
-const allEqualTo = curry((val, list) => all(equals(val), list));
-
-export default allEqualTo;

package/src/allIdentical.js

@@ -1,26 +0,0 @@
-import { uniqWith, identical, pipe, curryN } from 'ramda';
-
-import lengthLte from './lengthLte.js';
-
-/**
- * Returns true if all items in the list are equivalent using `R.identical` for equality comparisons.
- *
- * @func allIdentical
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.11.0|v2.11.0}
- * @category List
- * @sig [a] -> Boolean
- * @param {Array} list The list of values
- * @return {boolean}
- * @see {@link https://ramdajs.com/docs/#identical|identical}
- * @example
- *
- * RA.allIdentical([ 1, 2, 3, 4 ]); //=> false
- * RA.allIdentical([ 1, 1, 1, 1 ]); //=> true
- * RA.allIdentical([]); //=> true
- * RA.allIdentical([ {}, {} ]); //=> false
- * RA.allIdentical([ () => {}, () => {} ]); //=> false
- */
-const allIdentical = curryN(1, pipe(uniqWith(identical), lengthLte(1)));
-
-export default allIdentical;

package/src/allIdenticalTo.js

@@ -1,25 +0,0 @@
-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.
- *
- * @func allIdenticalTo
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.11.0|v2.11.0}
- * @category List
- * @sig a -> [b] -> Boolean
- * @param {*} val User provided value to check the `list` against
- * @param {Array} list The list of values
- * @return {boolean}
- * @see {@link RA.allIdentical|allIdentical}, {@link http://ramdajs.com/docs/#identical|R.identical}
- * @example
- *
- * RA.allIdenticalTo(1, [ 1, 2, 3, 4 ]); //=> false
- * RA.allIdenticalTo(1, [ 1, 1, 1, 1 ]); //=> true
- * RA.allIdenticalTo(1, []); //=> true
- * RA.allIdenticalTo({}, [ {}, {} ]); //=> false
- *
- */
-const allIdenticalTo = curry((val, list) => all(identical(val), list));
-
-export default allIdenticalTo;

package/src/allP.js

@@ -1,27 +0,0 @@
-import { bind, curryN } from 'ramda';
-
-/**
- * Composable shortcut for `Promise.all`.
- *
- * The `allP` method returns a single Promise that resolves when all of the promises
- * in the iterable argument have resolved or when the iterable argument contains no promises.
- * It rejects with the reason of the first promise that rejects.
- *
- * @func allP
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.3.0|v2.3.0}
- * @category Function
- * @sig [Promise a] -> Promise [a]
- * @param {Iterable.<*>} iterable An iterable object such as an Array or String
- * @return {Promise} An already resolved Promise if the iterable passed is empty. An asynchronously resolved Promise if the iterable passed contains no promises. Note, Google Chrome 58 returns an already resolved promise in this case. A pending Promise in all other cases. This returned promise is then resolved/rejected asynchronously (as soon as the stack is empty) when all the promises in the given iterable have resolved, or if any of the promises reject. See the example about "Asynchronicity or synchronicity of allP" below.
- * @see {@link RA.resolveP|resolveP}, {@link RA.rejectP|rejectP}
- * @example
- *
- * RA.allP([1, 2]); //=> Promise([1, 2])
- * RA.allP([1, Promise.resolve(2)]); //=> Promise([1, 2])
- * RA.allP([Promise.resolve(1), Promise.resolve(2)]); //=> Promise([1, 2])
- * RA.allP([1, Promise.reject(2)]); //=> Promise(2)
- */
-const allP = curryN(1, bind(Promise.all, Promise));
-
-export default allP;

package/src/allSettledP.js

@@ -1,34 +0,0 @@
-import { bind, curryN } from 'ramda';
-
-import isFunction from './isFunction.js';
-import ponyfill from './internal/ponyfills/Promise.allSettled.js';
-
-export const 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.
- * We say that a promise is settled if it is not pending, i.e. if it is either fulfilled or rejected.
- *
- * @func allSettledP
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.18.0|v2.18.0}
- * @category Function
- * @typedef Settlement = { status: String, value: * }
- * @sig [Promise a] -> Promise [Settlement a]
- * @param {Iterable.<*>} iterable An iterable object such as an Array or String
- * @return {Promise} Returns a promise that is fulfilled with an array of promise state snapshots
- * @see {@link RA.allP|allP}
- * @example
- *
- * RA.allSettledP([
- *   Promise.resolve(1),
- *   2,
- *   Promise.reject(3),
- * ]); //=> Promise([{ status: 'fulfilled', value: 1 }, { status: 'fulfilled', value: 2 }, { status: 'rejected', reason: 3 }])
- */
-const allSettledP = isFunction(Promise.allSettled)
-  ? curryN(1, bind(Promise.allSettled, Promise))
-  : allSettledPPonyfill;
-
-export default allSettledP;

package/src/allUnique.js

@@ -1,25 +0,0 @@
-import { converge, length, uniq } from 'ramda';
-
-import lengthEq from './lengthEq.js';
-
-/**
- * Returns true if all items in the list are unique. `R.equals` is used to determine equality.
- *
- * @func allUnique
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
- * @category List
- * @sig [a] -> Boolean
- * @param {Array} list The list of values
- * @return {boolean}
- * @see {@link RA.notAllUnique|notAllUnique},  {@link https://ramdajs.com/docs/#equals|equals}
- * @example
- *
- * RA.allUnique([ 1, 2, 3, 4 ]); //=> true
- * RA.allUnique([ 1, 1, 2, 3 ]); //=> false
- * RA.allUnique([]); //=> true
- *
- */
-const allUnique = converge(lengthEq, [length, uniq]);
-
-export default allUnique;

package/src/anyP.js

@@ -1,33 +0,0 @@
-import { bind, curryN } from 'ramda';
-
-import isFunction from './isFunction.js';
-import ponyfill, { AggregatedError } from './internal/ponyfills/Promise.any.js';
-
-export const 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.
- *
- * @func anyP
- * @memberOf RA
- * @category Function
- * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.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 first given promise to be fulfilled, or rejected with an array of rejection reasons if all of the given promises are rejected
- * @see {@link RA.lastP|lastP}
- * @example
- *
- * RA.anyP([
- *   Promise.resolve(1),
- *   2,
- *   Promise.reject(3),
- * ]); //=> Promise(1)
- */
-const anyP = isFunction(Promise.any)
-  ? curryN(1, bind(Promise.any, Promise))
-  : anyPPonyfill;
-
-export default anyP;

package/src/appendFlipped.js

@@ -1,24 +0,0 @@
-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.
- *
- * @func appendFlipped
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
- * @category List
- * @sig [a] -> a -> [a]
- * @param {Array} list The list of elements to add a new item to
- * @param {*} el The element to add to the end of the new list
- * @return {Array} A new list containing the elements of the old list followed by `el`
- * @see {@link http://ramdajs.com/docs/#append|R.append}
- * @example
- *
- * RA.appendFlipped(['write', 'more'], 'tests'); //=> ['write', 'more', 'tests']
- * RA.appendFlipped([], 'tests'); //=> ['tests']
- * RA.appendFlipped(['write', 'more'], ['tests']); //=> ['write', 'more', ['tests']]
- */
-const appendFlipped = flip(append);
-
-export default appendFlipped;

package/src/argsPass.js

@@ -1,40 +0,0 @@
-import { useWith, curry, compose } from 'ramda';
-
-import list from './list.js';
-import isTruthy from './isTruthy.js';
-
-/**
- * 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
- * returned from each function to the combining predicate. A combining predicate is a function that
- * combines a list of Boolean values into a single Boolean value, such as `R.any` or `R.all`. It
- * will test each value using `RA.isTruthy`, meaning the functions don't necessarily have to be
- * predicates.
- *
- * The function returned is curried to the number of functions supplied, and if called with more
- * arguments than functions, any remaining arguments are passed in to the combining predicate
- * untouched.
- *
- * @func argsPass
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.7.0|v2.7.0}
- * @category Logic
- * @sig ((* -> Boolean) -> [*] -> Boolean) -> [(* -> Boolean), ...] -> (*...) -> Boolean
- * @param {Function} combiningPredicate The predicate used to combine the values returned from the
- * list of functions
- * @param {Array} functions List of functions
- * @return {boolean} Returns the combined result of mapping arguments to functions
- * @example
- *
- * RA.argsPass(R.all, [RA.isArray, RA.isBoolean, RA.isString])([], false, 'abc') //=> true
- * RA.argsPass(R.all, [RA.isArray, RA.isBoolean, RA.isString])([], false, 1) //=> false
- * RA.argsPass(R.any, [RA.isArray, RA.isBoolean, RA.isString])({}, 1, 'abc') //=> true
- * RA.argsPass(R.any, [RA.isArray, RA.isBoolean, RA.isString])({}, 1, false) //=> false
- * 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
- */
-const argsPass = curry((combiningPredicate, predicates) =>
-  useWith(compose(combiningPredicate(isTruthy), list), predicates)
-);
-
-export default argsPass;

package/src/async.js

@@ -1,60 +0,0 @@
-import { curryN, bind } from 'ramda';
-
-import resolveP from './resolveP.js';
-import rejectP from './rejectP.js';
-
-/**
- * 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.
- *
- * Note: This function is handy for environments that does support generators but doesn't support async/await.
- *
- * @func async
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.16.0|v2.16.0}
- * @category Function
- * @sig Promise c => (a, b, ...) -> a -> b -> ... -> c
- * @param {Function} generatorFn The generator function
- * @return {Function} Curried async function
- * @see {@link https://www.promisejs.org/generators/}
- * @example
- *
- * const asyncFn = RA.async(function* generator(val1, val2) {
- *   const a = yield Promise.resolve(val1);
- *   const b = yield Promise.resolve(val2);
- *
- *   return a + b;
- * });
- *
- * asyncFn(1, 2); //=> Promise(3)
- *
- */
-const async = curryN(1, (generatorFn) => {
-  function asyncWrapper(...args) {
-    const iterator = bind(generatorFn, this)(...args);
-
-    const handle = (result) => {
-      const resolved = resolveP(result.value);
-
-      return result.done
-        ? resolved
-        : resolved.then(
-            (value) => handle(iterator.next(value)),
-            (error) => 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/src/cata.js

@@ -1,86 +0,0 @@
-import { curry } from 'ramda';
-
-import isFunction from './isFunction.js';
-
-/**
- * The catamorphism is a way of folding a type into a value.
- *
- * **Either**
- *
- * If the either is right then the right function will be executed with
- * the `right` value and the value of the function returned. Otherwise the left function
- * will be called with the `left` value.
- *
- * **Maybe**
- *
- * If the maybe is Some than the right function will be executed with the `some` value and the value of the function
- * returned. Otherwise the left function with be called without an argument.
- *
- * **Result**
- *
- * If the result is Ok than the right function will be executed with the `Ok` value and the value of the function
- * returned. Otherwise the left function will be called with the `Error` value.
- *
- * **Validation**
- *
- * If the validation is Success than the right function will be executed with the `Success` value and the value of the function
- * returned. Otherwise the left function will be called with the `Failure` value.
- *
- * Supported monadic libraries: {@link https://monet.github.io/monet.js/|monet.js}, {@link https://folktale.origamitower.com/|folktale}, {@link https://github.com/ramda/ramda-fantasy|ramda-fantasy}
- *
- * @func cata
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.4.0|v1.4.0}
- * @category Function
- * @sig (a -> b) -> (a -> c) -> Cata a -> b | c
- * @param {Function} leftFn The left function that consumes the left value
- * @param {Function} rightFn The right function that consumes the right value
- * @param {Cata} catamorphicObj Either, Maybe or any other type with catamorphic capabilities (`cata` or `either` method)
- * @return {*}
- * @see {@link https://monet.github.io/monet.js/#cata|cata explained}
- * @example
- *
- * // Either
- * const eitherR = Either.Right(1);
- * const eitherL = Either.Left(2);
- *
- * RA.cata(identity, identity, eitherR); //=> 1
- * RA.cata(identity, identity, eitherL); //=> 2
- *
- * // Maybe
- * const maybeSome = Maybe.Some(1);
- * const maybeNothing = Maybe.Nothing();
- *
- * RA.cata(identity, identity, maybeSome); //=> 1
- * RA.cata(identity, identity, maybeNothing); //=> undefined
- */
-const catamorphism = curry((leftFn, rightFn, catamorphicObj) => {
-  // folktale support
-  if (isFunction(catamorphicObj.matchWith)) {
-    return catamorphicObj.matchWith({
-      // Result type
-      Ok: ({ value }) => rightFn(value),
-      Error: ({ value }) => leftFn(value),
-      // Maybe type
-      Just: ({ value }) => rightFn(value),
-      Nothing: () => leftFn(undefined),
-      // Validation type
-      Success: ({ value }) => rightFn(value),
-      Failure: ({ value }) => leftFn(value),
-    });
-  }
-
-  if (isFunction(catamorphicObj.cata)) {
-    return catamorphicObj.cata(leftFn, rightFn);
-  }
-
-  if (isFunction(catamorphicObj.getOrElse)) {
-    const elseValue = `RA.cata${Math.random()}`;
-    const value = catamorphicObj.getOrElse(elseValue);
-    return value === elseValue ? leftFn() : rightFn(value);
-  }
-
-  return catamorphicObj.either(leftFn, rightFn);
-});
-
-export default catamorphism;

package/src/catchP.js

@@ -1,25 +0,0 @@
-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
- * and the promise instance itself.
- *
- * @func catchP
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.29.0|v2.29.0}
- * @category Function
- * @sig (a -> Promise b | b) -> Promise b
- * @param {Function} onRejected A Function called if the Promise is rejected. This function has one argument, the rejection reason.
- * @param {Promise} promise Any Promise
- * @return {Promise} Returns a Promise with dealt rejected cases
- * @see {@link RA.thenP|thenP}, {@link RA.resolveP|resolveP}, {@link RA.rejectP|rejectP}, {@link RA.allP|allP}
- *
- * @example
- *
- * RA.catchP(() => 'b', Promise.resolve('a')); //=> Promise('a')
- * RA.catchP(() => 'b', Promise.reject('a')); //=> Promise('b')
- */
-const catchP = invoker(1, 'catch');
-
-export default catchP;

package/src/ceil.js

@@ -1,28 +0,0 @@
-import { bind, curryN } from 'ramda';
-
-/**
- * Returns the smallest integer greater than or equal to a given number.
- *
- * Note: ceil(null) returns integer 0 and does not give a NaN error.
- *
- * @func ceil
- * @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 ceil
- * @return {number} The smallest integer greater than or equal to the given number
- * @example
- *
- * RA.ceil(.95); //=> 1
- * RA.ceil(4); //=> 4
- * RA.ceil(7.004); //=> 8
- * RA.ceil(-0.95); //=> -0
- * RA.ceil(-4); //=> -4
- * RA.ceil(-7.004); //=> -7
- * RA.ceil(null); //=> 0
- */
-
-const ceil = curryN(1, bind(Math.ceil, Math));
-
-export default ceil;

package/src/compact.js

@@ -1,23 +0,0 @@
-import { reject } from 'ramda';
-
-import isFalsy from './isFalsy.js';
-
-/**
- * Creates an array with all falsy values removed.
- * The values false, null, 0, "", undefined, and NaN are falsy.
- *
- * @func compact
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
- * @category List
- * @sig Filterable f => f a -> f a
- * @param {Array} list The array to compact
- * @return {Array} Returns the new array of filtered values
- * @see {@link RA.isFalsy|isFalsy}
- * @example
- *
- * RA.compact([0, 1, false, 2, '', 3]); //=> [1, 2, 3]
- */
-const compact = reject(isFalsy);
-
-export default compact;

package/src/concatAll.js

@@ -1,35 +0,0 @@
-import { concat, identical, identity, pipe, reduce, when } from 'ramda';
-
-import stubUndefined from './stubUndefined.js';
-
-const 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.
- * 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
- * concatAll(null); //=> undefined
- */
-const concatAll = pipe(
-  reduce(concat, leftIdentitySemigroup),
-  when(identical(leftIdentitySemigroup), stubUndefined)
-);
-
-export default concatAll;