ramda-adjunct 5.0.0 → 5.0.1

package/src/isNotPlainObj.js

@@ -1,35 +0,0 @@
-import { complement } from 'ramda';
-
-import isPlainObj from './isPlainObj.js';
-
-/* eslint-disable max-len */
-/**
- * Check to see if an object is a not plain object (created using `{}`, `new Object()` or `Object.create(null)`).
- *
- * @func isNotPlainObj
- * @aliases isNotPlainObject
- * @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.isPlainObj|isPlainObj}, {@link RA.isObjLike|isObjLike}, {@link RA.isObj|isObj}
- * @example
- *
- * class Bar {
- *   constructor() {
- *     this.prop = 'value';
- *   }
- * }
- *
- * RA.isNotPlainObj(new Bar()); //=> true
- * RA.isNotPlainObj({ prop: 'value' }); //=> false
- * RA.isNotPlainObj(['a', 'b', 'c']); //=> true
- * RA.isNotPlainObj(Object.create(null); //=> false
- * RA.isNotPlainObj(new Object()); //=> false
- */
-/* eslint-enable max-len */
-const isNotPlainObj = complement(isPlainObj);
-
-export default isNotPlainObj;

package/src/isNotPrimitive.js

@@ -1,26 +0,0 @@
-import { complement, curryN } from 'ramda';
-
-import isPrimitive from './isPrimitive.js';
-
-/**
- * Checks if value is not a primitive data type. There are 6 primitive data types: `string`, `number`, `bigint`, `boolean`, `undefined`, `symbol` and a special case of `null`.
- *
- * @func isNotPrimitive
- * @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.isPrimitive|isPrimitive}, {@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.isNotPrimitive(new String("string")); //=> true
- * RA.isNotPrimitive(new Number(1)); //=> true
- * RA.isNotPrimitive("string"); //=> false
- * RA.isNotPrimitive(1); //=> false
- */
-
-const isNotPrimitive = curryN(1, complement(isPrimitive));
-
-export default isNotPrimitive;

package/src/isNotRegExp.js

@@ -1,24 +0,0 @@
-import { complement } from 'ramda';
-
-import isRegExp from './isRegExp.js';
-
-/**
- * Checks if value is complement of `RegExp` object.
- *
- * @func isNotRegExp
- * @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.isRegExp|isRegExp}
- * @example
- *
- * RA.isNotRegExp(1); //=> true
- * RA.isNotRegExp(/(?:)/); //=> false
- * RA.isNotRegExp(new RegExp()); //=> false
- */
-const isNotRegExp = complement(isRegExp);
-
-export default isNotRegExp;

package/src/isNotSet.js

@@ -1,26 +0,0 @@
-import { complement } from 'ramda';
-
-import isSet from './isSet.js';
-
-/**
- * Checks if value is complement of `Set` object.
- *
- * @func isNotSet
- * @memberOf RA
- * @category Type
- * @since {@link https://char0n.github.io/ramda-adjunct/2.27.0|v2.27.0}
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isSet|isSet}
- * @example
- *
- * RA.isNotSet(new Map()); //=> true
- * RA.isNotSet(new Set()); //=> false
- * RA.isNotSet(new Set([1,2]); //=> false
- * RA.isNotSet(new Object()); //=> true
- */
-
-const isNotSet = complement(isSet);
-
-export default isNotSet;

package/src/isNotString.js

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

package/src/isNotUndefined.js

@@ -1,24 +0,0 @@
-import { complement } from 'ramda';
-
-import isUndefined from './isUndefined.js';
-
-/**
- * Checks if input value is complement `undefined`.
- *
- * @func isNotUndefined
- * @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.isUndefined|isUndefined}
- * @example
- *
- * RA.isNotUndefined(1); //=> true
- * RA.isNotUndefined(undefined); //=> false
- * RA.isNotUndefined(null); //=> true
- */
-const isNotUndefined = complement(isUndefined);
-
-export default isNotUndefined;

package/src/isNotValidDate.js

@@ -1,24 +0,0 @@
-import { complement } from 'ramda';
-
-import isValidDate from './isValidDate.js';
-
-/**
- * Checks if value is complement of valid `Date` object.
- *
- * @func isNotValidDate
- * @aliases isInvalidDate
- * @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.isValidDate|isValidDate}, {@link RA.isDate|isDate}, {@link RA.isNotDate|isNotDate}
- * @example
- *
- * RA.isNotValidDate(new Date()); //=> false
- * RA.isNotValidDate(new Date('a')); //=> true
- */
-const isNotValidDate = complement(isValidDate);
-
-export default isNotValidDate;

package/src/isNotValidNumber.js

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

package/src/isNull.js

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

package/src/isNumber.js

@@ -1,24 +0,0 @@
-import { curryN, pipe, type, identical } from 'ramda';
-
-/**
- * Checks if value is a `Number` primitive or object.
- *
- * @func isNumber
- * @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.isNotNumber|isNotNumber}
- * @example
- *
- * RA.isNumber(5); // => true
- * RA.isNumber(Number.MAX_VALUE); // => true
- * RA.isNumber(-Infinity); // => true
- * RA.isNumber(NaN); // => true
- * RA.isNumber('5'); // => false
- */
-const isNumber = curryN(1, pipe(type, identical('Number')));
-
-export default isNumber;

package/src/isObj.js

@@ -1,31 +0,0 @@
-import { both, either, curryN } from 'ramda';
-
-import isNotNull from './isNotNull.js';
-import isFunction from './isFunction.js';
-import isOfTypeObject from './internal/isOfTypeObject.js';
-
-/* eslint-disable max-len */
-/**
- * Checks if input value is language type of `Object`.
- *
- * @func isObj
- * @aliases isObject
- * @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.isNotObj|isNotObj}, {@link RA.isObjLike|isObjLike}, {@link RA.isPlainObj|isPlainObj}
- * @example
- *
- * RA.isObj({}); //=> true
- * RA.isObj([]); //=> true
- * RA.isObj(() => {}); //=> true
- * RA.isObj(null); //=> false
- * RA.isObj(undefined); //=> false
- */
-/* eslint-enable max-len */
-const isObj = curryN(1, both(isNotNull, either(isOfTypeObject, isFunction)));
-
-export default isObj;

package/src/isObjLike.js

@@ -1,30 +0,0 @@
-import { both, curryN } from 'ramda';
-
-import isNotNull from './isNotNull.js';
-import isOfTypeObject from './internal/isOfTypeObject.js';
-
-/* eslint-disable max-len */
-/**
- * Checks if value is object-like. A value is object-like if it's not null and has a typeof result of "object".
- *
- * @func isObjLike
- * @aliases isObjectLike
- * @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.isNotObjLike|isNotObjLike}, {@link RA.isObj|isObj}, {@link RA.isPlainObj|isPlainObj}
- * @example
- *
- * RA.isObjLike({}); //=> true
- * RA.isObjLike([]); //=> true
- * RA.isObjLike(() => {}); //=> false
- * RA.isObjLike(null); //=> false
- * RA.isObjLike(undefined); //=> false
- */
-/* eslint-enable max-len */
-const isObjLike = curryN(1, both(isNotNull, isOfTypeObject));
-
-export default isObjLike;

package/src/isOdd.js

@@ -1,29 +0,0 @@
-import { both, pipe, modulo, flip, equals, complement, curryN } from 'ramda';
-
-import isInteger from './isInteger.js';
-
-/**
- * Checks if value is odd integer number.
- * An odd number is an integer which is not a multiple DIVISIBLE of two.
- *
- * @func isOdd
- * @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.isEven|isEven}
- * @example
- *
- * RA.isOdd(1); // => true
- * RA.isOdd(-Infinity); // => false
- * RA.isOdd(4); // => false
- * RA.isOdd(3); // => true
- */
-const isOdd = curryN(
-  1,
-  both(isInteger, pipe(flip(modulo)(2), complement(equals)(0)))
-);
-
-export default isOdd;

package/src/isPair.js

@@ -1,27 +0,0 @@
-import { both, equals, length, pipe, curryN } from 'ramda';
-
-import isArray from './isArray.js';
-
-/**
- * Checks if input value is a pair.
- *
- * @func isPair
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.19.0|v1.19.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link http://ramdajs.com/docs/#pair|R.pair}, {@link RA.isNotPair|isNotPair}
- * @example
- *
- * RA.isPair([]); // => false
- * RA.isPair([0]); // => false
- * RA.isPair([0, 1]); // => true
- * RA.isPair([0, 1, 2]); // => false
- * RA.isPair({ 0: 0, 1: 1 }); // => false
- * RA.isPair({ foo: 0, bar: 0 }); // => false
- */
-const isPair = curryN(1, both(isArray, pipe(length, equals(2))));
-
-export default isPair;

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;