ramda-adjunct 2.30.0 → 2.33.0

package/src/fantasy-land/Identity.js

@@ -1,6 +1,6 @@
 import { empty as emptyR } from 'ramda';
 
-import fl from './mapping';
+import * as fl from './mapping';
 import {
   applyTrait,
   functorTrait,
@@ -10,9 +10,6 @@ import {
   ordTrait,
 } from './traits';
 
-// we do this here for jsdocs generate properly
-const { of, ap, map, equals, concat, chain, lte, empty, contramap } = fl;
-
 /**
  * The simplest {@link https://github.com/fantasyland/fantasy-land|fantasy-land}
  * compatible monad which attaches no information to values.
@@ -48,7 +45,7 @@ class Identity {
    *
    * const a = Identity.of(1); //=> Identity(1)
    */
-  static [of](value) {
+  static [fl.of](value) {
     return new Identity(value);
   }
 
@@ -98,12 +95,12 @@ class Identity {
    *
    * a.ap(b); //=> Identity(2)
    */
-  [ap](applyWithFn) {
-    return applyTrait[ap].call(this, applyWithFn);
+  [fl.ap](applyWithFn) {
+    return applyTrait[fl.ap].call(this, applyWithFn);
   }
 
   ap(applyWithFn) {
-    return this[ap](applyWithFn);
+    return this[fl.ap](applyWithFn);
   }
 
   /**
@@ -117,12 +114,12 @@ class Identity {
    * const a = Identity.of(1);
    * a.map(a => a + 1); //=> Identity(2)
    */
-  [map](fn) {
-    return functorTrait[map].call(this, fn);
+  [fl.map](fn) {
+    return functorTrait[fl.map].call(this, fn);
   }
 
   map(fn) {
-    return this[map](fn);
+    return this[fl.map](fn);
   }
 
   /**
@@ -140,12 +137,12 @@ class Identity {
    * a.equals(b); //=> true
    * a.equals(c); //=> false
    */
-  [equals](setoid) {
-    return setoidTrait[equals].call(this, setoid);
+  [fl.equals](setoid) {
+    return setoidTrait[fl.equals].call(this, setoid);
   }
 
   equals(setoid) {
-    return this[equals](setoid);
+    return this[fl.equals](setoid);
   }
 
   /**
@@ -168,12 +165,12 @@ class Identity {
    * const f = Identity.of(['f']);
    * e.concat(f); //=> ['e', 'f']
    */
-  [concat](semigroup) {
-    return semigroupTrait[concat].call(this, semigroup);
+  [fl.concat](semigroup) {
+    return semigroupTrait[fl.concat].call(this, semigroup);
   }
 
   concat(semigroup) {
-    return this[concat](semigroup);
+    return this[fl.concat](semigroup);
   }
 
   /**
@@ -189,12 +186,12 @@ class Identity {
    *
    * a.chain(fn).chain(fn); //=> Identity(3)
    */
-  [chain](fn) {
-    return chainTrait[chain].call(this, fn);
+  [fl.chain](fn) {
+    return chainTrait[fl.chain].call(this, fn);
   }
 
   chain(fn) {
-    return this[chain](fn);
+    return this[fl.chain](fn);
   }
 
   /**
@@ -213,12 +210,12 @@ class Identity {
    * a.lte(c); //=> true
    * c.lte(a); //=> false
    */
-  [lte](ord) {
-    return ordTrait[lte].call(this, ord);
+  [fl.lte](ord) {
+    return ordTrait[fl.lte].call(this, ord);
   }
 
   lte(ord) {
-    return this[lte](ord);
+    return this[fl.lte](ord);
   }
 
   /**
@@ -237,12 +234,12 @@ class Identity {
    * a.concat(i); //=> Identity('string');
    * i.concat(a); //=> Identity('string');
    */
-  [empty]() {
+  [fl.empty]() {
     return this.constructor.of(emptyR(this.value));
   }
 
   empty() {
-    return this[empty]();
+    return this[fl.empty]();
   }
 
   /**
@@ -261,12 +258,12 @@ class Identity {
    * Identity.of(identity).contramap(divide2).contramap(add1).get()(3); //=> 2
    * Identity.of(identity).contramap(a => divide2(add1(a))).get()(3); //=> 2
    */
-  [contramap](fn) {
+  [fl.contramap](fn) {
     return this.constructor.of((value) => this.value(fn(value)));
   }
 
   contramap(fn) {
-    return this[contramap](fn);
+    return this[fl.contramap](fn);
   }
 }
 

package/src/fantasy-land/mapping.js

@@ -1,24 +1,20 @@
-const mapping = Object.freeze({
-  equals: 'fantasy-land/equals',
-  lte: 'fantasy-land/lte',
-  compose: 'fantasy-land/compose',
-  id: 'fantasy-land/id',
-  concat: 'fantasy-land/concat',
-  empty: 'fantasy-land/empty',
-  map: 'fantasy-land/map',
-  contramap: 'fantasy-land/contramap',
-  ap: 'fantasy-land/ap',
-  of: 'fantasy-land/of',
-  alt: 'fantasy-land/alt',
-  zero: 'fantasy-land/zero',
-  reduce: 'fantasy-land/reduce',
-  traverse: 'fantasy-land/traverse',
-  chain: 'fantasy-land/chain',
-  chainRec: 'fantasy-land/chainRec',
-  extend: 'fantasy-land/extend',
-  extract: 'fantasy-land/extract',
-  bimap: 'fantasy-land/bimap',
-  promap: 'fantasy-land/promap',
-});
-
-export default mapping;
+export const equals = 'fantasy-land/equals';
+export const lte = 'fantasy-land/lte';
+export const compose = 'fantasy-land/compose';
+export const id = 'fantasy-land/id';
+export const concat = 'fantasy-land/concat';
+export const empty = 'fantasy-land/empty';
+export const map = 'fantasy-land/map';
+export const contramap = 'fantasy-land/contramap';
+export const ap = 'fantasy-land/ap';
+export const of = 'fantasy-land/of';
+export const alt = 'fantasy-land/alt';
+export const zero = 'fantasy-land/zero';
+export const reduce = 'fantasy-land/reduce';
+export const traverse = 'fantasy-land/traverse';
+export const chain = 'fantasy-land/chain';
+export const chainRec = 'fantasy-land/chainRec';
+export const extend = 'fantasy-land/extend';
+export const extract = 'fantasy-land/extract';
+export const bimap = 'fantasy-land/bimap';
+export const promap = 'fantasy-land/promap';

package/src/fantasy-land/traits.js

@@ -4,7 +4,7 @@ import isString from '../isString';
 import isNumber from '../isNumber';
 import isFunction from '../isFunction';
 import { isSameType } from './util';
-import fl from './mapping';
+import * as fl from './mapping';
 
 export const functorTrait = {
   [fl.map](fn) {

package/src/filterIndexed.js

@@ -0,0 +1,28 @@
+import { addIndex, filter } from 'ramda';
+
+/**
+ * {@link http://ramdajs.com/docs/#filter|R.filter} function that more closely resembles `Array.prototype.filter`.
+ * It takes two new parameters to its callback function: the current index, and the entire list.
+ *
+ * `filterIndexed` implementation is simple: `
+ *  const filterIndexed = R.addIndex(R.filter);
+ * `
+ *
+ * @func filterIndexed
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.31.0|v2.31.0}
+ * @category List
+ * @typedef Idx = Number
+ * @sig Filterable f => ((a, Idx, f a) -> Boolean) -> f a -> f a
+ * @param {Function} pred The predicate function
+ * @param {Array} list The collection to filter
+ * @return {Array} Filterable
+ * @see {@link http://ramdajs.com/docs/#addIndex|R.addIndex}, {@link http://ramdajs.com/docs/#filter|R.filter}
+ * @example
+ *
+ * const isValueGtIndex = (val, idx) => val > idx;
+ * RA.filterIndexed(isValueGtIndex, [5, 4, 3, 2, 1, 0]); //=> [5, 4, 3]
+ */
+const filterIndexed = addIndex(filter);
+
+export default filterIndexed;

package/src/findOr.js

@@ -0,0 +1,30 @@
+import { pipe, curry, find, defaultTo } from 'ramda';
+
+/**
+ * Returns the first element of the list which matches the predicate.
+ * Returns default value if no element matches or matched element is `null`, `undefined` or `NaN`.
+ * Dispatches to the find method of the second argument, if present.
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func findOr
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.32.0|v2.32.0}
+ * @category List
+ * @sig  a -> (b -> Boolean) -> [b] -> b | a
+ * @param {*} defaultValue The default value
+ * @param {Function} fn The predicate function used to determine if the element is the desired one.
+ * @param {Array} list The array to consider.
+ * @return {*} The element found, or the default value.
+ * @see {@link http://ramdajs.com/docs/#defaultTo|R.defaultTo}, {@link http://ramdajs.com/docs/#find|R.find}
+ * @example
+ *
+ * RA.findOr(1, isUndefined, [1, 2, undefined]); // => 1
+ * RA.findOr(1, val => val === 2, [1, 2, undefined]); // => 2
+ * RA.findOr(1, val => val === 3, [1, 2, undefined]); // => 1
+ */
+
+const findOr = curry((defaultVal, fn, list) =>
+  pipe(find(fn), defaultTo(defaultVal))(list)
+);
+
+export default findOr;

package/src/fnull.js

@@ -24,15 +24,15 @@ import mapIndexed from './mapIndexed';
  * addDefaults(undefined, undefined); // => 9
  */
 
-const fnull = curry((fn, defaults) => {
-  return curryN(fn.length, (...args) => {
+const fnull = curry((fn, defaults) =>
+  curryN(fn.length, (...args) => {
     const argsWithDefaults = mapIndexed(
       (val, idx) => defaultWhen(isNil, defaults[idx], val),
       args
     );
 
     return apply(fn, argsWithDefaults);
-  });
-});
+  })
+);
 
 export default fnull;

package/src/index.js

@@ -61,6 +61,8 @@ export { default as isNotNaN } from './isNotNaN';
 export { default as isFinite } from './isFinite';
 export { default as isNotFinite } from './isNotFinite';
 export { default as isInteger } from './isInteger';
+export { default as isInteger32 } from './isInteger32';
+export { default as isInt32 } from './isInteger32'; // alias of isInteger32
 export { default as isNotInteger } from './isNotInteger';
 export { default as isBigInt } from './isBigInt';
 export { default as isFloat } from './isFloat';
@@ -87,6 +89,9 @@ export { default as isSafeInteger } from './isSafeInteger';
 export { default as isIndexed } from './isIndexed';
 export { default as isError } from './isError';
 export { default as isNaturalNumber } from './isNaturalNumber';
+export { default as isPrimitive } from './isPrimitive';
+export { default as isNotPrimitive } from './isNotPrimitive';
+export { default as isSentinelValue } from './isSentinelValue';
 // Function
 export { default as stubUndefined } from './stubUndefined';
 export { default as stubNull } from './stubNull';
@@ -103,6 +108,7 @@ export { default as weaveLazy } from './weaveLazy';
 export { default as curryRightN } from './curryRightN';
 export { default as curryRight } from './curryRight';
 export { default as allP } from './allP';
+export { default as catchP } from './catchP';
 export { default as noneP } from './noneP';
 export { default as resolveP } from './resolveP';
 export { default as rejectP } from './rejectP';
@@ -123,6 +129,7 @@ export { default as fnull } from './fnull';
 // List
 export { default as mapIndexed } from './mapIndexed';
 export { default as reduceIndexed } from './reduceIndexed';
+export { default as filterIndexed } from './filterIndexed';
 export { default as pickIndexes } from './pickIndexes';
 export { default as list } from './list';
 export { default as ensureArray } from './ensureArray';
@@ -156,7 +163,9 @@ export { default as notAllUnique } from './notAllUnique';
 export { default as sortByProps } from './sortByProps';
 export { default as skipTake } from './skipTake';
 export { default as rangeStep } from './rangeStep';
+export { default as findOr } from './findOr';
 // Object
+export { default as invoke } from './invoke';
 export { default as invokeArgs } from './invokeArgs';
 export { default as paths } from './paths';
 export { default as renameKeys } from './renameKeys';
@@ -179,6 +188,7 @@ export { default as flattenProp } from './flattenProp';
 export { default as flattenPath } from './flattenPath';
 export { default as unzipObjWith } from './unzipObjWith';
 export { default as zipObjWith } from './zipObjWith';
+export { default as isPrototypeOf } from './isPrototypeOf';
 // Relation
 export { default as lensEq } from './lensEq';
 export { default as lensNotEq } from './lensNotEq';

package/src/internal/ap.js

@@ -1,7 +1,7 @@
 import { ap as apR, curryN, pathSatisfies, both, either } from 'ramda';
 
 import isFunction from '../isFunction';
-import fl from '../fantasy-land/mapping';
+import * as fl from '../fantasy-land/mapping';
 
 const isFunctor = either(
   pathSatisfies(isFunction, ['map']),

package/src/internal/makeFlat.js

@@ -14,8 +14,8 @@ import isArrayLike from '../isArrayLike';
  * @sig Bool -> List -> List
  *
  */
-const makeFlat = (recursive) => {
-  return function flatt(list) {
+const makeFlat = (recursive) =>
+  function flatt(list) {
     let value;
     let jlen;
     let j;
@@ -38,6 +38,5 @@ const makeFlat = (recursive) => {
     }
     return result;
   };
-};
 
 export default makeFlat;

package/src/internal/ponyfills/Promise.allSettled.js

@@ -7,9 +7,10 @@ const onFulfill = (value) => ({ status: 'fulfilled', value });
 const onReject = (reason) => ({ status: 'rejected', reason });
 
 const allSettledPonyfill = (iterable) => {
-  const array = map((p) => resolveP(p).then(onFulfill).catch(onReject), [
-    ...iterable,
-  ]);
+  const array = map(
+    (p) => resolveP(p).then(onFulfill).catch(onReject),
+    [...iterable]
+  );
 
   return allP(array);
 };

package/src/invoke.js

@@ -0,0 +1,22 @@
+import { __ } from 'ramda';
+
+import invokeArgs from './invokeArgs';
+
+/**
+ * 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/isInteger32.js

@@ -0,0 +1,28 @@
+import { curryN } from 'ramda';
+
+import toInteger32 from './toInteger32';
+
+/**
+ * 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/isNotPrimitive.js

@@ -0,0 +1,25 @@
+import { complement, curryN } from 'ramda';
+
+import isPrimitive from './isPrimitive';
+
+/**
+ * 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
+ * @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/isPrimitive.js

@@ -0,0 +1,45 @@
+import { both, anyPass } from 'ramda';
+
+import isNotObj from './isNotObj';
+import isString from './isString';
+import isNumber from './isNumber';
+import isBigInt from './isBigInt';
+import isBoolean from './isBoolean';
+import isUndefined from './isUndefined';
+import isNull from './isNull';
+import isSymbol from './isSymbol';
+
+/**
+ * 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
+ * @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/isPrototypeOf.js

@@ -0,0 +1,36 @@
+import { curry } from 'ramda';
+
+import invokeArgs from './invokeArgs';
+
+/**
+ * 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/isSentinelValue.js

@@ -0,0 +1,26 @@
+import { curryN } from 'ramda';
+
+import isInteger32 from './isInteger32';
+
+/**
+ * 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/isSymbol.js

@@ -19,11 +19,11 @@ import { type, curryN } from 'ramda';
  * RA.isSymbol(undefined); //=> false
  * RA.isSymbol(null); //=> false
  */
-const isSymbol = curryN(1, (val) => {
-  return (
+const isSymbol = curryN(
+  1,
+  (val) =>
     typeof val === 'symbol' ||
     (typeof val === 'object' && type(val) === 'Symbol')
-  );
-});
+);
 
 export default isSymbol;

package/src/pathOrLazy.js

@@ -19,12 +19,12 @@ import { curryN, identical, partial, pathOr, unary, when } from 'ramda';
  * RA.pathOrLazy(() => 'N/A', ['a', 'b'], {a: {b: 2}}); //=> 2
  * RA.pathOrLazy(() => 'N/A', ['a', 'b'], {c: {b: 2}}); //=> "N/A"
  */
-const pathOrLazy = curryN(3, function pathOrLazy(defaultFn, path, obj) {
-  return when(
+const pathOrLazy = curryN(3, (defaultFn, path, obj) =>
+  when(
     identical(defaultFn),
     partial(unary(defaultFn), [obj]),
     pathOr(defaultFn, path, obj)
-  );
-});
+  )
+);
 
 export default pathOrLazy;

package/src/replaceAll.js

@@ -28,7 +28,6 @@ export const replaceAllInvoker = invoker(2, 'replaceAll');
  * RA.replaceAll(/x/g, 'v', 'xxx'); //=> 'vvv'
  * RA.replaceAll(/x/, 'v', 'xxx'); //=> TypeError
  */
-
 const replaceAll = isFunction(String.prototype.replaceAll)
   ? replaceAllInvoker
   : replaceAllPonyfill;