ramda-adjunct 5.0.0 → 5.1.0

package/src/invoke.js

@@ -1,22 +0,0 @@
-import { __ } from 'ramda';
-
-import invokeArgs from './invokeArgs.js';
-
-/**
- * Invokes the method at path of object.
- *
- * @func invoke
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.31.0|v2.31.0}
- * @category Object
- * @sig Array -> Object -> *
- * @param {Array.<string|number>} path The path of the method to invoke
- * @param {Object} obj The object to query
- * @return {*}
- * @example
- *
- * RA.invoke(['random'], Math); //=> 0.5113253820009047
- */
-const invoke = invokeArgs(__, [], __);
-
-export default invoke;

package/src/invokeArgs.js

@@ -1,36 +0,0 @@
-import { curryN, path, apply, init, bind } from 'ramda';
-
-import isNotFunction from './isNotFunction.js';
-import isEmptyArray from './isEmptyArray.js';
-
-/**
- * Invokes the method at path of object with given arguments.
- *
- * @func invokeArgs
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.27.0|v2.27.0}
- * @category Object
- * @sig Array -> Array -> Object -> *
- * @param {Array.<string|number>} path The path of the method to invoke
- * @param {Array} args The arguments to invoke the method with
- * @param {Object} obj The object to query
- * @return {*}
- * @example
- *
- * RA.invokeArgs(['abs'], [-1], Math); //=> 1
- * RA.invokeArgs(['path', 'to', 'non-existent', 'method'], [-1], Math); //=> undefined
- */
-
-const invokeArgs = curryN(3, (mpath, args, obj) => {
-  const method = path(mpath, obj);
-  const context = path(init(mpath), obj);
-
-  if (isNotFunction(method)) return undefined;
-  if (isEmptyArray(mpath)) return undefined;
-
-  const boundMethod = bind(method, context);
-
-  return apply(boundMethod, args);
-});
-
-export default invokeArgs;

package/src/isArray.js

@@ -1,27 +0,0 @@
-import { curryN, pipe, type, identical } from 'ramda';
-
-import isFunction from './isFunction.js';
-
-/**
- * Checks if input value is `Array`.
- *
- * @func isArray
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/0.3.0|v0.3.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link RA.isNotArray|isNotArray}
- * @example
- *
- * RA.isArray([]); //=> true
- * RA.isArray(null); //=> false
- * RA.isArray({}); //=> false
- */
-const isArray = curryN(
-  1,
-  isFunction(Array.isArray) ? Array.isArray : pipe(type, identical('Array'))
-);
-
-export default isArray;

package/src/isArrayLike.js

@@ -1,79 +0,0 @@
-import { has, curryN } from 'ramda';
-
-import isArray from './isArray.js';
-import isString from './isString.js';
-
-/* eslint-disable max-len */
-/**
- * Tests whether or not an object is similar to an array.
- *
- * @func isArrayLike
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.9.0|v1.9.0}
- * @licence https://github.com/ramda/ramda/blob/master/LICENSE.txt
- * @category List
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @returns {boolean} `true` if `val` has a numeric length property and extreme indices defined; `false` otherwise.
- * @see {@link RA.isNotArrayLike|isNotArrayLike}
-
- * @example
- *
- * RA.isArrayLike([]); //=> true
- * RA.isArrayLike(true); //=> false
- * RA.isArrayLike({}); //=> false
- * RA.isArrayLike({length: 10}); //=> false
- * RA.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true
- */
-/* eslint-enable max-len */
-const isArrayLike = curryN(1, (val) => {
-  if (isArray(val)) {
-    return true;
-  }
-  if (!val) {
-    return false;
-  }
-  if (isString(val)) {
-    return false;
-  }
-  if (typeof val !== 'object') {
-    return false;
-  }
-  if (val.nodeType === 1) {
-    return !!val.length;
-  }
-  if (val.length === 0) {
-    return true;
-  }
-  if (val.length > 0) {
-    return has(0, val) && has(val.length - 1, val);
-  }
-  return false;
-});
-
-export default isArrayLike;
-
-/**
- The MIT License (MIT)
-
- Copyright (c) 2013-2016 Scott Sauyet and Michael Hurley
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
-*/

package/src/isAsyncFunction.js

@@ -1,23 +0,0 @@
-import { pipe, type, identical, curryN } from 'ramda';
-
-/**
- * Checks if input value is `Async Function`.
- *
- * @func isAsyncFunction
- * @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.isNotAsyncFunction|isNotAsyncFunction}, {@link RA.isGeneratorFunction|isGeneratorFunction}
- * @example
- *
- * RA.isAsyncFunction(async function test() { }); //=> true
- * RA.isAsyncFunction(null); //=> false
- * RA.isAsyncFunction(function test() { }); //=> false
- * RA.isAsyncFunction(() => {}); //=> false
- */
-const isAsyncFunction = curryN(1, pipe(type, identical('AsyncFunction')));
-
-export default isAsyncFunction;

package/src/isBigInt.js

@@ -1,24 +0,0 @@
-import { type, pipe, identical, curryN } from 'ramda';
-
-/**
- * Checks if value is a BigInt.
- *
- * @func isBigInt
- * @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}
- * @example
- *
- * RA.isBigInt(5); // => false
- * RA.isBigInt(Number.MAX_VALUE); // => false
- * RA.isBigInt(-Infinity); // => false
- * RA.isBigInt(10); // => false
- * RA.isBigInt(10n); // => true
- * RA.isBigInt(BitInt(9007199254740991)); // => true
- */
-const isBigInt = curryN(1, pipe(type, identical('BigInt')));
-
-export default isBigInt;

package/src/isBlank.js

@@ -1,33 +0,0 @@
-import { isEmpty, isNil, anyPass, test } from 'ramda';
-
-import isFalse from './isFalse.js';
-/**
- * Returns `true` if the given value is its type's empty value, `false`, `undefined`
- * as well as strings containing only whitespace characters; `false` otherwise.
- *
- * @func isBlank
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/3.1.0|v3.1.0}
- * @category Type
- * @sig * -> Boolean
- * @param {*} val The value to test
- * @return {boolean}
- * @see {@link https://blog.appsignal.com/2018/09/11/differences-between-nil-empty-blank-and-present.html|Differences Between #nil?, #empty?, #blank?, and #present?}
- * @example
- *
- * RA.isBlank(''); //=> true
- * RA.isBlank('   '); //=> true
- * RA.isBlank('\t\n'); //=> true
- * RA.isBlank({}); //=> true
- * RA.isBlank(null); //=> true
- * RA.isBlank(undefined); //=> true
- * RA.isBlank([]); //=> true
- * RA.isBlank(false); //=> true
- * RA.isBlank('value'); //=> false
- * RA.isBlank({ foo: 'foo' }); //=> false
- * RA.isBlank([1, 2, 3]); //=> false
- * RA.isBlank(true); //=> false
- */
-const isBlank = anyPass([isFalse, isNil, isEmpty, test(/^\s+$/gm)]);
-
-export default isBlank;

package/src/isBoolean.js

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

package/src/isDate.js

@@ -1,21 +0,0 @@
-import { type, identical, pipe, curryN } from 'ramda';
-
-/**
- * Checks if value is `Date` object.
- *
- * @func isDate
- * @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.isNotDate|isNotDate}, {@link RA.isValidDate|isValidDate}, {@link RA.isNotValidDate|isNotValidDate}
- * @example
- *
- * RA.isDate(new Date()); //=> true
- * RA.isDate('1997-07-16T19:20+01:00'); //=> false
- */
-const isDate = curryN(1, pipe(type, identical('Date')));
-
-export default isDate;

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;