ramda-adjunct 5.0.0 → 5.1.0

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;

package/src/concatRight.js

@@ -1,30 +0,0 @@
-import { concat, flip } from '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([], []); //=> []
- */
-const concatRight = flip(concat);
-
-export default concatRight;

package/src/copyKeys.js

@@ -1,31 +0,0 @@
-import { curryN } from 'ramda';
-
-import renameKeys from './renameKeys.js';
-
-/**
- * Creates a new object with the own properties of the provided object, and the
- * keys copied according to the keysMap object as `{oldKey: newKey}`.
- * When no key from the keysMap is found, then a shallow clone of an object is returned.
- *
- * Keep in mind that in the case of keys conflict is behaviour undefined and
- * the result may vary between various JS engines!
- *
- * @func copyKeys
- * @memberOf RA
- * @category Object
- * @sig {a: b} -> {a: *} -> {b: *}
- * @param {!Object} keysMap
- * @param {!Object} obj
- * @return {!Object} New object with copied keys
- * @see {@link RA.renameKeys|renameKeys}
- * @example
- *
- * copyKeys({ a: 'b' }, { a: true }); //=> { a: true, b: true }
- * copyKeys({ a: 'b' }, { a: true, b: false }); //=> { a: true, b: true }
- */
-const copyKeys = curryN(2, (keysMap, obj) => ({
-  ...obj,
-  ...renameKeys(keysMap, obj),
-}));
-
-export default copyKeys;

package/src/curryRight.js

@@ -1,26 +0,0 @@
-import { converge, length, identity } from 'ramda';
-
-import curryRightN from './curryRightN.js';
-
-/**
- * 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'
- */
-const curryRight = converge(curryRightN, [length, identity]);
-
-export default curryRight;

package/src/curryRightN.js

@@ -1,29 +0,0 @@
-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.
- *
- * @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'
- */
-const curryRightN = curryN(2, (arity, fn) =>
-  curryN(arity, function wrapper(...args) {
-    return fn.apply(this, reverse(args));
-  })
-);
-
-export default curryRightN;

package/src/defaultWhen.js

@@ -1,26 +0,0 @@
-import { curry } from '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
- */
-const defaultWhen = curry((predicate, defaultVal, val) =>
-  predicate(val) ? defaultVal : val
-);
-
-export default defaultWhen;

package/src/delayP.js

@@ -1,45 +0,0 @@
-import { curry, propOr, partial, nth } from 'ramda';
-
-import isNonNegative from './isNonNegative.js';
-import isInteger from './isInteger.js';
-
-/**
- * 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'))
- */
-
-const makeDelay = curry((settleFnPicker, opts) => {
-  let timeout;
-  let value;
-
-  if (isInteger(opts) && isNonNegative(opts)) {
-    timeout = opts;
-  } else {
-    timeout = propOr(0, 'timeout', opts);
-    value = propOr(value, 'value', opts);
-  }
-
-  return new Promise((...args) => {
-    const settleFn = settleFnPicker(args);
-
-    setTimeout(partial(settleFn, [value]), timeout);
-  });
-});
-
-const delayP = makeDelay(nth(0));
-delayP.reject = makeDelay(nth(1));
-
-export default delayP;

package/src/dispatch.js

@@ -1,74 +0,0 @@
-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).
- * Consumes dispatching functions and keep trying to invoke each in turn, until a non-nil value is returned.
- *
- * Accepts a list of dispatching functions and returns a new function.
- * When invoked, this new function is applied to some arguments,
- * each dispatching function is applied to those same arguments until one of the
- * dispatching functions returns a non-nil value.
- *
- * @func dispatch
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}
- * @category Function
- * @sig [((a, b, ...) -> x1), ((a, b, ...) -> x2), ...] -> x1 | x2 | ...
- * @param {!Array} functions A list of functions
- * @return {*|undefined} Returns the first not-nil value, or undefined if either an empty list is provided or none of the dispatching functions returns a non-nil value
- * @see {@link RA.isNotNil}
- * @example
- *
- * // returns first non-nil value
- * const stubNil = () => null;
- * const stubUndefined = () => undefined;
- * const addOne = v => v + 1;
- * const addTwo = v => v + 2;
- *
- * RA.dispatch([stubNil, stubUndefined, addOne, addTwo])(1); //=> 2
- *
- * // acts as a switch
- * const fnSwitch = RA.dispatch([
- *   R.ifElse(RA.isString, s => `${s}-join`, RA.stubUndefined),
- *   R.ifElse(RA.isNumber, n => n + 1, RA.stubUndefined),
- *   R.ifElse(RA.isDate, R.T, RA.stubUndefined),
- * ]);
- * fnSwitch(1); //=> 2
- */
-import isNotNil from './isNotNil.js';
-import isNonEmptyArray from './isNonEmptyArray.js';
-import stubUndefined from './stubUndefined.js';
-
-const byArity = comparator((a, b) => a.length > b.length);
-
-const getMaxArity = pipe(sort(byArity), head, prop('length'));
-
-const iteratorFn = curry((args, accumulator, fn) => {
-  const result = fn(...args);
-
-  return isNotNil(result) ? reduced(result) : accumulator;
-});
-
-const dispatchImpl = (functions) => {
-  const arity = getMaxArity(functions);
-
-  return curryN(arity, (...args) =>
-    reduce(iteratorFn(args), undefined, functions)
-  );
-};
-
-const dispatch = ifElse(isNonEmptyArray, dispatchImpl, stubUndefined);
-
-export default dispatch;

package/src/divideNum.js

@@ -1,20 +0,0 @@
-import { divide, flip } from '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
- */
-const divideNum = flip(divide);
-
-export default divideNum;

package/src/dropArgs.js

@@ -1,23 +0,0 @@
-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.
- *
- * @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
- */
-const dropArgs = nAry(0);
-
-export default dropArgs;

package/src/ensureArray.js

@@ -1,24 +0,0 @@
-import { when, of } from 'ramda';
-
-import isNotArray from './isNotArray.js';
-
-/**
- * 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]
- */
-const ensureArray = when(isNotArray, of(Array));
-
-export default ensureArray;

package/src/escapeRegExp.js

@@ -1,22 +0,0 @@
-import { when, replace } from 'ramda';
-
-import isString from './isString.js';
-
-/**
- * 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\)'
- */
-const escapeRegExp = when(isString, replace(/[.*+?^${}()|[\]\\-]/g, '\\$&'));
-
-export default escapeRegExp;