ramda-adjunct 5.0.0 → 5.0.1

package/src/isEmptyArray.js

@@ -1,28 +0,0 @@
-import { both, isEmpty } from 'ramda';
-
-import isArray from './isArray.js';
-
-/**
- * Checks if input value is an empty `Array`.
- *
- * @func isEmptyArray
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.4.0|v2.4.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isNotEmptyArray|isNotEmptyArray}
- * @example
- *
- * RA.isEmptyArray([]); // => true
- * RA.isEmptyArray([42]); // => false
- * RA.isEmptyArray({}); // => false
- * RA.isEmptyArray(null); // => false
- * RA.isEmptyArray(undefined); // => false
- * RA.isEmptyArray(42); // => false
- * RA.isEmptyArray('42'); // => false
- */
-const isEmptyArray = both(isArray, isEmpty);
-
-export default isEmptyArray;

package/src/isEmptyString.js

@@ -1,28 +0,0 @@
-import { equals } from 'ramda';
-
-/**
- * Checks if input value is an empty `String`.
- *
- * @func isEmptyString
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.4.0|v2.4.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isNotEmptyString|isNotEmptyString}
- * @example
- *
- * RA.isEmptyString(''); // => true
- * RA.isEmptyString('42'); // => false
- * RA.isEmptyString(new String('42')); // => false
- * RA.isEmptyString(new String('')); // => false
- * RA.isEmptyString([42]); // => false
- * RA.isEmptyString({}); // => false
- * RA.isEmptyString(null); // => false
- * RA.isEmptyString(undefined); // => false
- * RA.isEmptyString(42); // => false
- */
-const isEmptyString = equals('');
-
-export default isEmptyString;

package/src/isError.js

@@ -1,21 +0,0 @@
-import { type, identical, pipe, curryN } from 'ramda';
-
-/**
- * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, `SyntaxError`, `TypeError` or `URIError` object.
- *
- * @func isError
- * @category Type
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.30.0|v2.30.0}
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean} Returns `true` if value is an error object, `false` otherwise
- * @example
- *
- * RA.isError(new Error()); //=> true
- * RA.isError(Error); //=> false
- * RA.isError(1); // => false
- */
-const isError = curryN(1, pipe(type, identical('Error')));
-
-export default isError;

package/src/isEven.js

@@ -1,31 +0,0 @@
-import { both, complement, curryN } from 'ramda';
-
-import isInteger from './isInteger.js';
-import isOdd from './isOdd.js';
-
-/**
- * Checks if value is even integer number.
- * An even number is an integer which is "evenly divisible" by two.
- * Zero is an even number because zero divided by two equals zero,
- * which despite not being a natural number, is an integer.
- * Even numbers are either positive or negative.
- *
- * @func isEven
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.18.0|v1.18.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isOdd|isOdd}
- * @example
- *
- * RA.isEven(0); // => true
- * RA.isEven(1); // => false
- * RA.isEven(-Infinity); // => false
- * RA.isEven(4); // => true
- * RA.isEven(3); // => false
- */
-const isEven = curryN(1, both(isInteger, complement(isOdd)));
-
-export default isEven;

package/src/isFalse.js

@@ -1,31 +0,0 @@
-import { identical, curryN } from 'ramda';
-
-/**
- * Checks if input value is the Boolean primitive `false`. Will return false for all values created
- * using the `Boolean` function as a constructor.
- *
- * @func isFalse
- * @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.isTrue|isTrue}, {@link RA.isTruthy|isTruthy}, {@link RA.isFalsy|isFalsy}
- * @example
- *
- * RA.isFalse(false); // => true
- * RA.isFalse(Boolean(false)); // => true
- * RA.isFalse(true); // => false
- * RA.isFalse(0); // => false
- * RA.isFalse(''); // => false
- * RA.isFalse(null); // => false
- * RA.isFalse(undefined); // => false
- * RA.isFalse(NaN); // => false
- * RA.isFalse([]); // => false
- * RA.isFalse(new Boolean(false)); // => false
- */
-
-const isFalse = curryN(1, identical(false));
-
-export default isFalse;

package/src/isFalsy.js

@@ -1,28 +0,0 @@
-import { complement } from 'ramda';
-
-import isTruthy from './isTruthy.js';
-
-/**
- * A falsy value is a value that translates to false when evaluated in a Boolean context.
- * Falsy values are `false`, `0`, `""`, `null`, `undefined`, and `NaN`.
- *
- * @func isFalsy
- * @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/Falsy|falsy}, {@link RA.isTruthy|isTruthy}
- * @example
- *
- * RA.isFalsy(false); // => true
- * RA.isFalsy(0); // => true
- * RA.isFalsy(''); // => true
- * RA.isFalsy(null); // => true
- * RA.isFalsy(undefined); // => true
- * RA.isFalsy(NaN); // => true
- */
-const isFalsy = complement(isTruthy);
-
-export default isFalsy;

package/src/isFinite.js

@@ -1,37 +0,0 @@
-import { bind, curryN } from 'ramda';
-
-import isFunction from './isFunction.js';
-import ponyfill from './internal/ponyfills/Number.isFinite.js';
-
-export const isFinitePonyfill = curryN(1, ponyfill);
-
-/**
- * Checks whether the passed value is a finite `Number`.
- *
- * @func isFinite
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/0.7.0|v0.7.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isNotFinite|isNotFinite}
- * @example
- *
- * RA.isFinite(Infinity); //=> false
- * RA.isFinite(NaN); //=> false
- * RA.isFinite(-Infinity); //=> false
- *
- * RA.isFinite(0); // true
- * RA.isFinite(2e64); // true
- *
- * RA.isFinite('0');  // => false
- *                    // would've been true with global isFinite('0')
- * RA.isFinite(null); // => false
- *                    // would've been true with global isFinite(null)
- */
-const _isFinite = isFunction(Number.isFinite)
-  ? curryN(1, bind(Number.isFinite, Number))
-  : isFinitePonyfill;
-
-export default _isFinite;

package/src/isFloat.js

@@ -1,36 +0,0 @@
-import { complement, both } from 'ramda';
-
-import isInteger from './isInteger.js';
-import isFinite from './isFinite.js';
-
-/**
- * Checks whether the passed value is a `float`.
- *
- * @func isFloat
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.14.0|v1.14.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isNotFloat|isNotFloat}
- * @example
- *
- * RA.isFloat(0); //=> false
- * RA.isFloat(1); //=> false
- * RA.isFloat(-100000); //=> false
- *
- * RA.isFloat(0.1);       //=> true
- * RA.isFloat(Math.PI);   //=> true
- *
- * RA.isFloat(NaN);       //=> false
- * RA.isFloat(Infinity);  //=> false
- * RA.isFloat(-Infinity); //=> false
- * RA.isFloat('10');      //=> false
- * RA.isFloat(true);      //=> false
- * RA.isFloat(false);     //=> false
- * RA.isFloat([1]);       //=> false
- */
-const isFloat = both(isFinite, complement(isInteger));
-
-export default isFloat;

package/src/isFunction.js

@@ -1,32 +0,0 @@
-import { anyPass, type, pipe, identical } from 'ramda';
-
-import isGeneratorFunction from './isGeneratorFunction.js';
-import isAsyncFunction from './isAsyncFunction.js';
-
-/**
- * Checks if input value is `Function`.
- *
- * @func isFunction
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/0.5.0|v0.5.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isNotFunction|isNotFunction}, {@link RA.isAsyncFunction|isNotAsyncFunction}, {@link RA.isGeneratorFunction|isGeneratorFunction}
- * @example
- *
- * RA.isFunction(function test() { }); //=> true
- * RA.isFunction(function* test() { }); //=> true
- * RA.isFunction(async function test() { }); //=> true
- * RA.isFunction(() => {}); //=> true
- * RA.isFunction(null); //=> false
- * RA.isFunction('abc'); //=> false
- */
-const isFunction = anyPass([
-  pipe(type, identical('Function')),
-  isGeneratorFunction,
-  isAsyncFunction,
-]);
-
-export default isFunction;

package/src/isGeneratorFunction.js

@@ -1,26 +0,0 @@
-import { type, identical, pipe, curryN } from 'ramda';
-
-/**
- * Checks if input value is `Generator Function`.
- *
- * @func isGeneratorFunction
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/0.5.0|v0.5.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isFunction|isFunction}, {@link RA.isAsyncFunction|isAsyncFunction}, {@link RA.isNotGeneratorFunction|isNotGeneratorFunction}
- * @example
- *
- * RA.isGeneratorFunction(function* test() { }); //=> true
- * RA.isGeneratorFunction(null); //=> false
- * RA.isGeneratorFunction(function test() { }); //=> false
- * RA.isGeneratorFunction(() => {}); //=> false
- */
-const isGeneratorFunction = curryN(
-  1,
-  pipe(type, identical('GeneratorFunction'))
-);
-
-export default isGeneratorFunction;

package/src/isIndexed.js

@@ -1,24 +0,0 @@
-import { either, curryN } from 'ramda';
-
-import isArray from './isArray.js';
-import isString from './isString.js';
-
-/**
- * Determine if input value is an indexed data type.
- *
- * @func isIndexed
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.26.0|v2.26.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @example
- *
- * RA.isIndexed([1]) //=> true
- * RA.isIndexed('test') //=> true
- */
-
-const isIndexed = curryN(1, either(isString, isArray));
-
-export default isIndexed;

package/src/isInteger.js

@@ -1,40 +0,0 @@
-import { bind, curryN } from 'ramda';
-
-import isFunction from './isFunction.js';
-import ponyfill from './internal/ponyfills/Number.isInteger.js';
-
-export const isIntegerPonyfill = curryN(1, ponyfill);
-
-/**
- * Checks whether the passed value is an `integer`.
- *
- * @func isInteger
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/0.7.0|v0.7.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isNotInteger|isNotInteger}
- * @example
- *
- * RA.isInteger(0); //=> true
- * RA.isInteger(1); //=> true
- * RA.isInteger(-100000); //=> true
- *
- * RA.isInteger(0.1);       //=> false
- * RA.isInteger(Math.PI);   //=> false
- *
- * RA.isInteger(NaN);       //=> false
- * RA.isInteger(Infinity);  //=> false
- * RA.isInteger(-Infinity); //=> false
- * RA.isInteger('10');      //=> false
- * RA.isInteger(true);      //=> false
- * RA.isInteger(false);     //=> false
- * RA.isInteger([1]);       //=> false
- */
-const isInteger = isFunction(Number.isInteger)
-  ? curryN(1, bind(Number.isInteger, Number))
-  : isIntegerPonyfill;
-
-export default isInteger;

package/src/isInteger32.js

@@ -1,28 +0,0 @@
-import { curryN } from 'ramda';
-
-import toInteger32 from './toInteger32.js';
-
-/**
- * Checks whether the passed value is a signed 32 bit integer.
- *
- * @func isInteger32
- * @aliases isInt32
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.32.0|v2.32.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.toInteger32|toInteger32}
- * @example
- *
- * RA.isInteger32(0); //=> true
- * RA.isInteger32((-2) ** 31); //=> true
- *
- * RA.isInteger32(Infinity); //=> false
- * RA.isInteger32(NaN); //=> false
- * RA.isInteger32(2 ** 31); //=> false
- */
-const isInteger32 = curryN(1, (val) => toInteger32(val) === val);
-
-export default isInteger32;

package/src/isIterable.js

@@ -1,37 +0,0 @@
-import { hasIn, curryN } from 'ramda';
-
-import isFunction from './isFunction.js';
-
-/**
- * Checks whether the passed value is iterable.
- *
- * @func isIterable
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.18.0|v2.18.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol}
- * @return {boolean}
- * @example
- *
- * RA.isIterable(['arrays', 'are', 'iterable']); //=> true
- * RA.isIterable('strings are iterable, too'); //=> true
- * RA.isIterable((function* () {})()); //=> true (generator objects are both iterable and iterators)
- *
- * RA.isIterable({}); //=> false
- * RA.isIterable(-0); //=> false
- * RA.isIterable(null); //=> false
- * RA.isIterable(undefined); //=> false
- */
-const isIterable = curryN(1, (val) => {
-  if (typeof Symbol === 'undefined') {
-    return false;
-  }
-
-  return (
-    hasIn(Symbol.iterator, Object(val)) && isFunction(val[Symbol.iterator])
-  );
-});
-
-export default isIterable;

package/src/isMap.js

@@ -1,25 +0,0 @@
-import { type, identical, pipe, curryN } from 'ramda';
-
-/**
- * Predicate for determining if a provided value is an instance of a Map.
- *
- * @func isMap
- * @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.isSet|isSet}}
- * @example
- *
- * RA.isMap(new Map()); //=> true
- * RA.isMap(new Map([[1, 2], [2, 1]])); //=> true
- * RA.isSet(new Set()); //=> false
- * RA.isSet(new Set([1,2]); //=> false
- * RA.isSet(new Object()); //=> false
- */
-
-const isMap = curryN(1, pipe(type, identical('Map')));
-
-export default isMap;

package/src/isNaN.js

@@ -1,45 +0,0 @@
-import { curryN } from 'ramda';
-
-import isFunction from './isFunction.js';
-import ponyfill from './internal/ponyfills/Number.isNaN.js';
-
-export const isNaNPonyfill = curryN(1, ponyfill);
-
-/**
- * Checks whether the passed value is `NaN` and its type is `Number`.
- * It is a more robust version of the original, global isNaN().
- *
- *
- * @func isNaN
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/0.6.0|v0.6.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isNotNaN|isNotNaN}
- * @example
- *
- * RA.isNaN(NaN); // => true
- * RA.isNaN(Number.NaN); // => true
- * RA.isNaN(0 / 0); // => true
- *
- * // e.g. these would have been true with global isNaN().
- * RA.isNaN('NaN'); // => false
- * RA.isNaN(undefined); // => false
- * RA.isNaN({}); // => false
- * RA.isNaN('blabla'); // => false
- *
- * RA.isNaN(true); // => false
- * RA.isNaN(null); // => false
- * RA.isNaN(37); // => false
- * RA.isNaN('37'); // => false
- * RA.isNaN('37.37'); // => false
- * RA.isNaN(''); // => false
- * RA.isNaN(' '); // => false
- */
-const _isNaN = isFunction(Number.isNaN)
-  ? curryN(1, Number.isNaN)
-  : isNaNPonyfill;
-
-export default _isNaN;

package/src/isNaturalNumber.js

@@ -1,28 +0,0 @@
-import { both, complement, curryN } from 'ramda';
-
-import isInteger from './isInteger.js';
-import isNegative from './isNegative.js';
-
-/**
- * Checks if value is a natural number.
- * Natural numbers correspond to all non-negative integers and 0.
- *
- * @func isNaturalNumber
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.29.0|v2.29.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @example
- *
- * RA.isNaturalNumber(5); // => true
- * RA.isNaturalNumber(Number.MAX_VALUE); // => true
- * RA.isNaturalNumber(0); // => true
- * RA.isNaturalNumber(-1); // => false
- * RA.isNaturalNumber(0.9); // => false
- */
-
-const isNaturalNumber = curryN(1, both(isInteger, complement(isNegative)));
-
-export default isNaturalNumber;

package/src/isNegative.js

@@ -1,27 +0,0 @@
-import { both, gt, curryN } from 'ramda';
-
-import isNumber from './isNumber.js';
-
-/**
- * Checks if value is a negative `Number` primitive or object. Zero is not considered neither
- * positive or negative.
- *
- * @func isNegative
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.15.0|v1.15.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isPositive|isPositive}
- * @example
- *
- * RA.isNegative(-1); // => true
- * RA.isNegative(Number.MIN_VALUE); // => false
- * RA.isNegative(+Infinity); // => false
- * RA.isNegative(NaN); // => false
- * RA.isNegative('5'); // => false
- */
-const isNegative = curryN(1, both(isNumber, gt(0)));
-
-export default isNegative;

package/src/isNegativeZero.js

@@ -1,23 +0,0 @@
-import { identical, curryN } from 'ramda';
-
-/**
- * Checks if value is a negative zero (-0).
- *
- * @func isNegativeZero
- * @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 @see {@link RA.isPositiveZero|isPositiveZero}
- * @example
- *
- * RA.isNegativeZero(-0); //=> true
- * RA.isNegativeZero(+0); //=> false
- * RA.isNegativeZero(0); //=> false
- * RA.isNegativeZero(null); //=> false
- */
-const isNegativeZero = curryN(1, identical(-0));
-
-export default isNegativeZero;

package/src/isNilOrEmpty.js

@@ -1,26 +0,0 @@
-import { either, isEmpty, isNil, curryN } from 'ramda';
-
-/**
- * Returns `true` if the given value is its type's empty value, `null` or `undefined`.
- *
- * @func isNilOrEmpty
- * @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 http://ramdajs.com/docs/#isEmpty|R.isEmpty}, {@link http://ramdajs.com/docs/#isNil|R.isNil}
- * @example
- *
- * RA.isNilOrEmpty([1, 2, 3]); //=> false
- * RA.isNilOrEmpty([]); //=> true
- * RA.isNilOrEmpty(''); //=> true
- * RA.isNilOrEmpty(null); //=> true
- * RA.isNilOrEmpty(undefined): //=> true
- * RA.isNilOrEmpty({}); //=> true
- * RA.isNilOrEmpty({length: 0}); //=> false
- */
-const isNilOrEmpty = curryN(1, either(isNil, isEmpty));
-
-export default isNilOrEmpty;

package/src/isNonEmptyArray.js

@@ -1,28 +0,0 @@
-import { both, isNotEmpty } from 'ramda';
-
-import isArray from './isArray.js';
-
-/**
- * Checks if input value is not an empty `Array`.
- *
- * @func isNonEmptyArray
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.4.0|v2.4.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isEmptyArray|isEmptyArray}
- * @example
- *
- * RA.isNonEmptyArray([42]); // => true
- * RA.isNonEmptyArray([]); // => false
- * RA.isNonEmptyArray({}); // => false
- * RA.isNonEmptyArray(null); // => false
- * RA.isNonEmptyArray(undefined); // => false
- * RA.isNonEmptyArray(42); // => false
- * RA.isNonEmptyArray('42'); // => false
- */
-const isNonEmptyArray = both(isArray, isNotEmpty);
-
-export default isNonEmptyArray;