ramda-adjunct 2.31.1 → 2.35.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/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/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';
@@ -157,6 +163,7 @@ 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';
@@ -164,6 +171,7 @@ export { default as paths } from './paths';
 export { default as renameKeys } from './renameKeys';
 export { default as renameKeysWith } from './renameKeysWith';
 export { default as renameKeyWith } from './renameKeyWith';
+export { default as copyKeys } from './copyKeys';
 export { default as mergeRight } from './mergeRight';
 export { default as mergeLeft } from './mergeRight';
 export { default as resetToDefault } from './mergeRight';

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/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/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/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/types/index.d.ts

@@ -44,6 +44,7 @@ declare namespace RamdaAdjunct {
     interface Dictionary<T> { [key: string]: T; }
 
     type DictPred<T> = (value: T, key: string) => boolean;
+    type Primitive = string | number | bigint | boolean | undefined | null | symbol;
 
     interface Static {
         /**
@@ -66,6 +67,18 @@ declare namespace RamdaAdjunct {
          */
         isBoolean(val: any): val is boolean;
 
+        /**
+         * 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.
+         */
+        isPrimitive<T>(val: T | Primitive): val is Primitive;
+
+        /**
+         * 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`.
+         */
+        isNotPrimitive<T>(val: T | Primitive): val is T;
+
         /**
          * Checks if an object exists in another object's prototype chain.
          */
@@ -105,7 +118,8 @@ declare namespace RamdaAdjunct {
         /**
          * Checks if input value is complement of `null` or `undefined`.
          */
-        isNotNil(val: any): boolean;
+        /* tslint:disable-next-line:no-null-undefined-union null or undefined is the accurate type here */
+        isNotNil<T>(val: T | null | undefined): val is T;
 
         /**
          * Checks if input value is complement of `null`.
@@ -341,6 +355,11 @@ declare namespace RamdaAdjunct {
          */
         isInteger(val: any): val is number;
 
+        /**
+         * Checks whether the passed value is a signed 32 bit `integer`.
+         */
+        isInteger32(val: any): boolean;
+
         /**
          * Checks whether the passed value is complement of `integer`.
          */
@@ -436,6 +455,12 @@ declare namespace RamdaAdjunct {
          */
         isSparseArray(val: any): boolean;
 
+        /**
+         * 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}.
+         */
+        isSentinelValue(val: any): boolean;
+
         /**
          * A function that returns `undefined`.
          */
@@ -569,6 +594,14 @@ declare namespace RamdaAdjunct {
         renameKeys(keysMap: Dictionary<string>, obj: object): object;
         renameKeys(keysMap: Dictionary<string>): (obj: object) => object;
 
+        /**
+         * Creates a new object with the own properties of the provided object, and the
+         * keys copied according to the keysMap object as `{oldKey: newKey}`.
+         * When no key from the keysMap is found, then a shallow clone of an object is returned.
+         */
+        copyKeys(keysMap: Dictionary<string>, obj: object): object;
+        copyKeys(keysMap: Dictionary<string>): (obj: object) => object;
+
         /**
          * Creates a new object with the own properties of the provided object, but the
          * keys renamed according to logic of renaming function.
@@ -977,6 +1010,14 @@ declare namespace RamdaAdjunct {
             reject<T>(options: { timeout: number, value: T }): Promise<T>
         };
 
+        /**
+         * Composable shortcut for `Promise.catch`.
+         * The catchP function returns a Promise. It takes two arguments: a callback function for the rejections of the Promise
+         * and the promise instance itself.
+         */
+        catchP<A, B = unknown>(onRejected: (error: any) => B | Promise<B>, promise: Promise<A>): Promise<A | B>;
+        catchP<A, B = unknown>(onRejected: (error: any) => B | Promise<B>): (promise: Promise<A>) => Promise<A | B>;
+
         /**
          * Composable shortcut for `Promise.then`.
          * The thenP function returns a Promise. It takes two arguments: a callback function for the success of the Promise
@@ -1157,6 +1198,19 @@ declare namespace RamdaAdjunct {
         defaultWhen<DefVal, Val>(predicate: Function, defaultVal: DefVal): (val: Val) => DefVal | Val;
         defaultWhen(predicate: Function): <DefVal, Val>(defaultVal: DefVal) => (val: Val) => DefVal | Val;
 
+        /**
+         * 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.
+         */
+        findOr<DefVal, T>(defaultVal: DefVal, predicate: (element: T) => boolean, list: ReadonlyArray<T>): T | DefVal;
+        findOr<DefVal, T>(defaultVal: DefVal, predicate: (element: T) => boolean): (list: ReadonlyArray<T>) => T | DefVal;
+        findOr<DefVal, T>(defaultVal: DefVal): {
+            (predicate: (element: T) => boolean, list: ReadonlyArray<T>): T | DefVal;
+            (predicate: (element: T) => boolean): (list: ReadonlyArray<T>) => T | DefVal;
+        };
+
         /**
          * Y-combinator
          *

package/.husky/commit-msg

@@ -1,4 +0,0 @@
-#!/bin/sh
-. "$(dirname "$0")/_/husky.sh"
-
-commitlint -e

package/.husky/pre-commit

@@ -1,4 +0,0 @@
-#!/bin/sh
-. "$(dirname "$0")/_/husky.sh"
-
-lint-staged

package/.mocharc.js

@@ -1,9 +0,0 @@
-'use strict';
-
-module.exports = {
-  recursive: true,
-  spec: 'test/**/*.js',
-  require: ['test/mocha-bootstrap.js'],
-  reporter: 'mocha-multi-reporters',
-  'reporter-options': 'configFile=test/mocha-multi.json',
-};