ramda-adjunct 5.0.0 → 5.1.0

package/src/isPlainObj.js

@@ -1,65 +0,0 @@
-import {
-  pipe,
-  type,
-  identical,
-  both,
-  equals,
-  toString,
-  pathSatisfies,
-  curryN,
-} from 'ramda';
-
-import isNull from './isNull.js';
-import isObjLike from './isObjLike.js';
-import isFunction from './isFunction.js';
-
-const isObject = pipe(type, identical('Object'));
-const isObjectConstructor = pipe(toString, equals(toString(Object)));
-const hasObjectConstructor = pathSatisfies(
-  both(isFunction, isObjectConstructor),
-  ['constructor']
-);
-
-/* eslint-disable max-len */
-/**
- * Check to see if an object is a plain object (created using `{}`, `new Object()` or `Object.create(null)`).
- *
- * @func isPlainObj
- * @aliases isPlainObject
- * @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.isNotPlainObj|isNotPlainObj}, {@link RA.isObjLike|isObjLike}, {@link RA.isObj|isObj}
- * @example
- *
- * class Bar {
- *   constructor() {
- *     this.prop = 'value';
- *   }
- * }
- *
- * RA.isPlainObj(new Bar()); //=> false
- * RA.isPlainObj({ prop: 'value' }); //=> true
- * RA.isPlainObj(['a', 'b', 'c']); //=> false
- * RA.isPlainObj(Object.create(null); //=> true
- * RA.isPlainObj(new Object()); //=> true
- */
-/* eslint-enable max-len */
-const isPlainObj = curryN(1, (val) => {
-  if (!isObjLike(val) || !isObject(val)) {
-    return false;
-  }
-
-  const proto = Object.getPrototypeOf(val);
-
-  if (isNull(proto)) {
-    return true;
-  }
-
-  return hasObjectConstructor(proto);
-});
-
-export default isPlainObj;

package/src/isPositive.js

@@ -1,26 +0,0 @@
-import { both, lt } from 'ramda';
-
-import isNumber from './isNumber.js';
-
-/**
- * Checks if value is a positive `Number` primitive or object. Zero is not considered positive.
- *
- * @func isPositive
- * @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.isNegative|isNegative}
- * @example
- *
- * RA.isPositive(1); // => true
- * RA.isPositive(Number.MAX_VALUE); // => true
- * RA.isPositive(-Infinity); // => false
- * RA.isPositive(NaN); // => false
- * RA.isPositive('5'); // => false
- */
-const isPositive = both(isNumber, lt(0));
-
-export default isPositive;

package/src/isPositiveZero.js

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

package/src/isPrimitive.js

@@ -1,46 +0,0 @@
-import { both, anyPass } from 'ramda';
-
-import isNotObj from './isNotObj.js';
-import isString from './isString.js';
-import isNumber from './isNumber.js';
-import isBigInt from './isBigInt.js';
-import isBoolean from './isBoolean.js';
-import isUndefined from './isUndefined.js';
-import isNull from './isNull.js';
-import isSymbol from './isSymbol.js';
-
-/**
- * Checks if value is a primitive data type. There are 6 primitive data types: `string`, `number`, `bigint`, `boolean`, `undefined`, `symbol` and a special case of `null`.
- * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Primitive_values
- * for definition of what sub-types comprise a primitive.
- *
- * @func isPrimitive
- * @memberOf RA
- * @category Type
- * @sig * -> Boolean
- * @since {@link https://char0n.github.io/ramda-adjunct/2.32.0|v2.32.0}
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isNotPrimitive|isNotPrimitive}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#primitive_values|MDN Primitive values}, {@link https://developer.mozilla.org/en-US/docs/Glossary/Primitive|MDN Primitive}
- * @example
- *
- * RA.isPrimitive("string"); //=> true
- * RA.isPrimitive(1); //=> true
- * RA.isPrimitive(new String("string")); //=> false
- * RA.isPrimitive(new Number(1)); //=> false
- */
-
-const isPrimitive = both(
-  isNotObj,
-  anyPass([
-    isString,
-    isNumber,
-    isBigInt,
-    isBoolean,
-    isUndefined,
-    isNull,
-    isSymbol,
-  ])
-);
-
-export default isPrimitive;

package/src/isPromise.js

@@ -1,32 +0,0 @@
-import { both, pipe, toString, equals, curryN } from 'ramda';
-
-import isObj from './isObj.js';
-
-/**
- * Checks if input value is a native `Promise`.
- * The Promise object represents the eventual completion (or failure)
- * of an asynchronous operation, and its resulting value.
- *
- * @func isPromise
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.1.0|v2.1.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link https://promisesaplus.com/|Promises/A+}, {@link RA.isThenable|isThenable}
- * @example
- *
- * RA.isPromise(null); // => false
- * RA.isPromise(undefined); // => false
- * RA.isPromise([]); // => false
- * RA.isPromise(Promise.resolve()); // => true
- * RA.isPromise(Promise.reject()); // => true
- * RA.isPromise({ then: () => 1 }); // => false
- */
-const isPromise = curryN(
-  1,
-  both(isObj, pipe(toString, equals('[object Promise]')))
-);
-
-export default isPromise;

package/src/isPrototypeOf.js

@@ -1,36 +0,0 @@
-import { curry } from 'ramda';
-
-import invokeArgs from './invokeArgs.js';
-
-/**
- * Checks if an object exists in another object's prototype chain.
- *
- * @func isPrototypeOf
- * @category Object
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.31.0|v2.31.0}
- * @sig * -> Boolean
- * @param {Object} type The prototype that we're searching for
- * @param {Object} object The object whose prototype chain will be searched
- * @return {boolean}
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isPrototypeOf|Object.prorotype.isPrototypeOf}
- * @example
- * function Foo() {}
- * function Bar() {}
- * function Baz() {}
- *
- * Bar.prototype = Object.create(Foo.prototype);
- * Baz.prototype = Object.create(Bar.prototype);
- *
- * const baz = new Baz();
- *
- * RA.isPrototypeOf(Baz, baz); // => true
- * RA.isPrototypeOf(Bar, baz); // => true
- * RA.isPrototypeOf(Foo, baz); // => true
- * RA.isPrototypeOf(Object, baz); // => true
- */
-const isPrototypeOf = curry((type, object) =>
-  Boolean(invokeArgs(['prototype', 'isPrototypeOf'], [object], type))
-);
-
-export default isPrototypeOf;

package/src/isRegExp.js

@@ -1,22 +0,0 @@
-import { type, identical, pipe, curryN } from 'ramda';
-
-/**
- * Checks if value is `RegExp` object.
- *
- * @func isRegExp
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isNotRegExp|isNotRegExp}
- * @example
- *
- * RA.isRegExp(new RegExp()); //=> true
- * RA.isRegExp(/(?:)/); //=> true
- * RA.isRegExp(1); //=> false
- */
-const isRegExp = curryN(1, pipe(type, identical('RegExp')));
-
-export default isRegExp;

package/src/isSafeInteger.js

@@ -1,40 +0,0 @@
-import { bind, curryN } from 'ramda';
-
-import isFunction from './isFunction.js';
-import ponyfill from './internal/ponyfills/Number.isSafeInteger.js';
-
-export const isSafeIntegerPonyfill = curryN(1, ponyfill);
-
-/**
- * Checks whether the passed value is a safe `integer`.
- *
- * @func isSafeInteger
- * @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}
- * @example
- *
- * RA.isSafeInteger(3); //=> true
- * RA.isSafeInteger(Math.pow(2, 53)) //=> false
- * RA.isSafeInteger(Math.pow(2, 53) - 1); //=> true
- * RA.isSafeInteger(NaN); //=> false
- * RA.isSafeInteger(Infinity); //=> false
- * RA.isSafeInteger('3') //=> false
- * RA.isSafeInteger(3.1); //=> false
- * RA.isSafeInteger(3.0); //=> true
- * RA.isSafeInteger('string'); //=> false
- * RA.isSafeInteger(null); //=> false
- * RA.isSafeInteger(undefined); //=> false
- * RA.isSafeInteger({}); //=> false
- * RA.isSafeInteger(() => { }); //=> false
- * RA.isSafeInteger(true); //=> false
- */
-
-const isSafeInteger = isFunction(Number.isSafeInteger)
-  ? curryN(1, bind(Number.isSafeInteger, Number))
-  : isSafeIntegerPonyfill;
-
-export default isSafeInteger;

package/src/isSentinelValue.js

@@ -1,26 +0,0 @@
-import { curryN } from 'ramda';
-
-import isInteger32 from './isInteger32.js';
-
-/**
- * Checks whether the passed value is {@link https://github.com/getify/You-Dont-Know-JS/blob/9959fc904d584bbf0b02cf41c192f74ff4238581/types-grammar/ch4.md#the-curious-case-of-the-|a sentinel value}.
- *
- * @func isSentinelValue
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.33.0|v2.33.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @example
- *
- * RA.isSentinelValue(-1); //=> true
- *
- * RA.isSentinelValue('-1'); //=> false
- * RA.isSentinelValue(1); //=> false
- * RA.isSentinelValue([-1]); //=> false
- */
-// eslint-disable-next-line no-bitwise
-const isSentinelValue = curryN(1, (val) => isInteger32(val) && ~val === 0);
-
-export default isSentinelValue;

package/src/isSet.js

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

package/src/isSparseArray.js

@@ -1,43 +0,0 @@
-import {
-  values,
-  both,
-  complement,
-  pipe,
-  converge,
-  identical,
-  length,
-} from 'ramda';
-
-import isArray from './isArray.js';
-
-/**
- * Checks if input value is a sparse Array.
- * An array with at least one "empty slot" in it is often called a "sparse array."
- * Empty slot doesn't mean that the slot contains `null` or `undefined` values,
- * but rather that the slots don't exist.
- *
- * @func isSparseArray
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.20.0|v2.20.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} list The list to test
- * @return {boolean}
- * @see {@link https://github.com/getify/You-Dont-Know-JS/blob/f0d591b6502c080b92e18fc470432af8144db610/types%20%26%20grammar/ch3.md#array|Sparse Arrays}, {@link RA.isArray|isArray}
- * @example
- *
- * RA.isSparseArray(new Array(3)); // => true
- * RA.isSparseArray([1,,3]); // => true
- *
- * const list = [1, 2, 3];
- * delete list[1];
- * RA.isSparseArray(list); // => true
- *
- * RA.isSparseArray([1, 2, 3]); // => false
- */
-const isSparseArray = both(
-  isArray,
-  converge(complement(identical), [pipe(values, length), length])
-);
-
-export default isSparseArray;

package/src/isString.js

@@ -1,21 +0,0 @@
-import { curryN, pipe, type, identical } from 'ramda';
-
-/**
- * Checks if input value is `String`.
- *
- * @func isString
- * @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 RA.isNotString|isNotString}
- * @example
- *
- * RA.isString('abc'); //=> true
- * RA.isString(1); //=> false
- */
-const isString = curryN(1, pipe(type, identical('String')));
-
-export default isString;

package/src/isSymbol.js

@@ -1,29 +0,0 @@
-import { type, curryN } from 'ramda';
-
-/**
- * Checks if input value is a Symbol.
- *
- * @func isSymbol
- * @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 https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol|MDN Symbol}
- * @example
- *
- * RA.isSymbol(Symbol('1')); //=> true
- * RA.isSymbol(Symbol(1)); //=> true
- * RA.isSymbol('string'); //=> false
- * RA.isSymbol(undefined); //=> false
- * RA.isSymbol(null); //=> false
- */
-const isSymbol = curryN(
-  1,
-  (val) =>
-    typeof val === 'symbol' ||
-    (typeof val === 'object' && type(val) === 'Symbol')
-);
-
-export default isSymbol;

package/src/isThenable.js

@@ -1,28 +0,0 @@
-import { pathSatisfies } from 'ramda';
-
-import isFunction from './isFunction.js';
-
-/**
- * Checks if input value is a `thenable`.
- * `thenable` is an object or function that defines a `then` method.
- *
- * @func isThenable
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.1.0|v2.1.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isPromise|isPromise}
- * @example
- *
- * RA.isThenable(null); // => false
- * RA.isThenable(undefined); // => false
- * RA.isThenable([]); // => false
- * RA.isThenable(Promise.resolve()); // => true
- * RA.isThenable(Promise.reject()); // => true
- * RA.isThenable({ then: () => 1 }); // => true
- */
-const isThenable = pathSatisfies(isFunction, ['then']);
-
-export default isThenable;

package/src/isTrue.js

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

package/src/isTruthy.js

@@ -1,28 +0,0 @@
-import { curryN } from 'ramda';
-
-/**
- * In JavaScript, a `truthy` value is a value that is considered true
- * when evaluated in a Boolean context. All values are truthy unless
- * they are defined as falsy (i.e., except for `false`, `0`, `""`, `null`, `undefined`, and `NaN`).
- *
- * @func isTruthy
- * @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/Truthy|truthy}, {@link RA.isFalsy|isFalsy}
- * @example
- *
- * RA.isTruthy({}); // => true
- * RA.isTruthy([]); // => true
- * RA.isTruthy(42); // => true
- * RA.isTruthy(3.14); // => true
- * RA.isTruthy('foo'); // => true
- * RA.isTruthy(new Date()); // => true
- * RA.isTruthy(Infinity); // => true
- */
-const isTruthy = curryN(1, Boolean);
-
-export default isTruthy;

package/src/isUinteger32.js

@@ -1,29 +0,0 @@
-import { curryN } from 'ramda';
-
-import toUinteger32 from './toUinteger32.js';
-
-/**
- * Checks whether the passed value is an unsigned 32 bit integer.
- *
- * @func isUinteger32
- * @aliases isUint32
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/3.2.0|v3.2.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.toUinteger32|toUinteger32}
- * @example
- *
- * RA.isUinteger32(0); //=> true
- * RA.isUinteger32(2 ** 32 - 1); //=> true
- *
- * RA.isUinteger32(Infinity); //=> false
- * RA.isUinteger32(NaN); //=> false
- * RA.isUinteger32(-1); //=> false
- * RA.isUinteger32(2 ** 32); //=> false
- */
-const isUinteger32 = curryN(1, (val) => toUinteger32(val) === val);
-
-export default isUinteger32;

package/src/isUndefined.js

@@ -1,24 +0,0 @@
-import { equals } from 'ramda';
-
-import stubUndefined from './stubUndefined.js';
-
-/**
- * Checks if input value is `undefined`.
- *
- * @func isUndefined
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/0.0.1|v0.0.1}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isNotUndefined|isNotUndefined}
- * @example
- *
- * RA.isUndefined(1); //=> false
- * RA.isUndefined(undefined); //=> true
- * RA.isUndefined(null); //=> false
- */
-const isUndefined = equals(stubUndefined());
-
-export default isUndefined;

package/src/isValidDate.js

@@ -1,29 +0,0 @@
-import { invoker, both, pipe, curryN } from 'ramda';
-
-import isDate from './isDate.js';
-import isNotNaN from './isNotNaN.js';
-
-/* eslint-disable max-len */
-/**
- * Checks if value is valid `Date` object.
- *
- * @func isValidDate
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.8.0|v1.8.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isDate|isDate}, {@link RA.isNotDate|isNotDate}, {@link RA.isNotValidDate|isNotValidDate}
- * @example
- *
- * RA.isValidDate(new Date()); //=> true
- * RA.isValidDate(new Date('a')); //=> false
- */
-/* eslint-enable max-len */
-const isValidDate = curryN(
-  1,
-  both(isDate, pipe(invoker(0, 'getTime'), isNotNaN))
-);
-
-export default isValidDate;

package/src/isValidNumber.js

@@ -1,28 +0,0 @@
-import { either, curryN } from 'ramda';
-
-import isFloat from './isFloat.js';
-import isInteger from './isInteger.js';
-
-/**
- * Checks if value is a valid `Number`. A valid `Number` is a number that is not `NaN`, `Infinity`
- * or `-Infinity`.
- *
- * @func isValidNumber
- * @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 RA.isNotValidNumber|isNotValidNumber}
- * @example
- *
- * RA.isValidNumber(1); //=> true
- * RA.isValidNumber(''); //=> false
- * RA.isValidNumber(NaN); //=> false
- * RA.isValidNumber(Infinity); //=> false
- * RA.isValidNumber(-Infinity); //=> false
- */
-const isValidNumber = curryN(1, either(isInteger, isFloat));
-
-export default isValidNumber;