ramda-adjunct 2.32.0 → 2.36.0

package/package.json

@@ -14,7 +14,7 @@
     "cookbook",
     "functional"
   ],
-  "version": "2.32.0",
+  "version": "2.36.0",
   "homepage": "https://github.com/char0n/ramda-adjunct",
   "license": "BSD-3-Clause",
   "repository": {
@@ -93,7 +93,7 @@
       }
     },
     "test:web": "testem ci",
-    "test:ramda": "bnr test:ramda0.27.1 && bnr test:ramda0.27.0 && bnr test:ramda0.26.1 && bnr test:ramda0.26.0 && bnr test:ramda0.25.0 && bnr test:ramda0.24.1 && bnr test:ramda0.24.0 && bnr test:ramda0.23.0 && bnr test:ramda0.22.1 && bnr test:ramda0.22.0 && bnr test:ramda0.21.0 && bnr test:ramda0.20.1 && bnr test:ramda0.20.0 && bnr test:ramda0.19.1 && bnr test:ramda0.19.0",
+    "test:ramda": "bnr test:ramda0.27.2 && bnr test:ramda0.27.1 && bnr test:ramda0.27.0 && bnr test:ramda0.26.1 && bnr test:ramda0.26.0 && bnr test:ramda0.25.0 && bnr test:ramda0.24.1 && bnr test:ramda0.24.0 && bnr test:ramda0.23.0 && bnr test:ramda0.22.1 && bnr test:ramda0.22.0 && bnr test:ramda0.21.0 && bnr test:ramda0.20.1 && bnr test:ramda0.20.0 && bnr test:ramda0.19.1 && bnr test:ramda0.19.0",
     "test:ramda0.19.0": "npm install ramda@0.19.0 && npm test",
     "test:ramda0.19.1": "npm install ramda@0.19.1 && npm test",
     "test:ramda0.20.0": "npm install ramda@0.20.0 && npm test",
@@ -109,6 +109,7 @@
     "test:ramda0.26.1": "npm install ramda@0.26.1 && npm test",
     "test:ramda0.27.0": "npm install ramda@0.27.0 && npm test",
     "test:ramda0.27.1": "npm install ramda@0.27.1 && npm test",
+    "test:ramda0.27.2": "npm install ramda@0.27.1 && npm test",
     "test:bundle-create": "webpack --config webpack.config-test.web.js --progress",
     "test:bundle-clean": "rimraf tmp-test-bundle.js",
     "coverage": {
@@ -136,63 +137,63 @@
   },
   "readme": "README.md",
   "peerDependencies": {
-    "ramda": ">= 0.19.0 <= 0.27.1"
+    "ramda": ">= 0.19.0 <= 0.27.2"
   },
   "devDependencies": {
-    "@babel/cli": "7.13.14",
-    "@babel/core": "7.13.15",
-    "@babel/plugin-transform-modules-commonjs": "7.13.8",
-    "@babel/preset-env": "7.12.11",
-    "@babel/register": "7.13.14",
-    "@commitlint/cli": "=12.1.1",
-    "@commitlint/config-conventional": "=12.1.1",
+    "@babel/cli": "7.16.8",
+    "@babel/core": "=7.16.7",
+    "@babel/plugin-transform-modules-commonjs": "7.16.8",
+    "@babel/preset-env": "=7.16.8",
+    "@babel/register": "7.16.9",
+    "@commitlint/cli": "=16.0.2",
+    "@commitlint/config-conventional": "=16.0.0",
     "assert": "=2.0.0",
-    "babel-loader": "8.2.2",
+    "babel-loader": "8.2.3",
     "babel-plugin-annotate-pure-calls": "0.4.0",
-    "babel-plugin-istanbul": "6.0.0",
+    "babel-plugin-istanbul": "6.1.1",
     "better-npm-run": "0.1.1",
     "chai": "4.3.4",
-    "codecov": "3.8.1",
-    "conventional-changelog-cli": "2.1.1",
-    "core-js": "=3.10.1",
+    "codecov": "3.8.3",
+    "conventional-changelog-cli": "2.2.2",
+    "core-js": "=3.20.3",
     "docdash": "git+https://github.com/char0n/docdash.git#534b44382138a55dd8d93642c979e51e46471185",
-    "dtslint": "=4.0.9",
-    "eslint": "7.23.0",
-    "eslint-config-airbnb-base": "14.2.1",
-    "eslint-config-prettier": "=8.1.0",
-    "eslint-plugin-import": "2.22.1",
-    "eslint-plugin-mocha": "8.1.0",
-    "eslint-plugin-prettier": "3.3.1",
+    "dtslint": "=4.2.1",
+    "eslint": "=8.7.0",
+    "eslint-config-airbnb-base": "=15.0.0",
+    "eslint-config-prettier": "=8.3.0",
+    "eslint-plugin-import": "=2.25.4",
+    "eslint-plugin-mocha": "10.0.3",
+    "eslint-plugin-prettier": "4.0.0",
     "eslint-plugin-ramda": "2.5.1",
-    "fantasy-land": "4.1.0",
+    "fantasy-land": "5.0.0",
     "fantasy-laws": "=1.2.0",
     "folktale": "=2.3.2",
-    "glob": "7.1.6",
-    "husky": "6.0.0",
+    "glob": "7.2.0",
+    "husky": "7.0.4",
     "istanbul": "=0.4.5",
-    "jsdoc": "3.6.6",
+    "jsdoc": "=3.6.7",
     "jsverify": "0.8.4",
     "license-cli": "1.1.6",
-    "lint-staged": "10.5.4",
-    "mocha": "=8.3.2",
-    "mocha-junit-reporter": "2.0.0",
+    "lint-staged": "12.1.7",
+    "mocha": "=9.1.4",
+    "mocha-junit-reporter": "2.0.2",
     "mocha-multi-reporters": "1.5.1",
-    "monet": "0.9.2",
+    "monet": "0.9.3",
     "nyc": "15.1.0",
-    "prettier": "=2.2.1",
+    "prettier": "=2.5.1",
     "process": "=0.11.10",
-    "ramda": "0.27.1",
+    "ramda": "0.27.2",
     "ramda-fantasy": "=0.8.0",
-    "regenerator-runtime": "=0.13.7",
+    "regenerator-runtime": "=0.13.9",
     "rimraf": "3.0.2",
     "sanctuary-show": "2.0.0",
-    "sinon": "10.0.1",
-    "terser-webpack-plugin": "5.1.1",
-    "testem": "=3.4.0",
+    "sinon": "=11.1.2",
+    "terser-webpack-plugin": "5.3.0",
+    "testem": "=3.6.0",
     "tslint": "=6.1.3",
-    "typescript": "=4.2.4",
-    "webpack": "=5.31.0",
-    "webpack-cli": "4.6.0"
+    "typescript": "=4.5.4",
+    "webpack": "=5.66.0",
+    "webpack-cli": "4.9.1"
   },
   "browserslist": "> 0.25%, ie 10, ie 11, not op_mini all",
   "tonicExampleFilename": "tonicExample.js",

package/src/catchP.js

@@ -0,0 +1,25 @@
+import { invoker } from 'ramda';
+
+/**
+ * Composable shortcut for `Promise.catch`.
+ * The catchP function returns a Promise. It takes two arguments: a callback function for the failure of the Promise
+ * and the promise instance itself.
+ *
+ * @func catchP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.29.0|v2.29.0}
+ * @category Function
+ * @sig (a -> Promise b | b) -> Promise b
+ * @param {Function} onRejected A Function called if the Promise is rejected. This function has one argument, the rejection reason.
+ * @param {Promise} promise Any Promise
+ * @return {Promise} Returns a Promise with dealt rejected cases
+ * @see {@link RA.thenP|thenP}, {@link RA.resolveP|resolveP}, {@link RA.rejectP|rejectP}, {@link RA.allP|allP}
+ *
+ * @example
+ *
+ * RA.catchP(() => 'b', Promise.resolve('a')); //=> Promise('a')
+ * RA.catchP(() => 'b', Promise.reject('a')); //=> Promise('b')
+ */
+const catchP = invoker(1, 'catch');
+
+export default catchP;

package/src/copyKeys.js

@@ -0,0 +1,31 @@
+import { curryN } from 'ramda';
+
+import renameKeys from './renameKeys';
+
+/**
+ * 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.
+ *
+ * Keep in mind that in the case of keys conflict is behaviour undefined and
+ * the result may vary between various JS engines!
+ *
+ * @func copyKeys
+ * @memberOf RA
+ * @category Object
+ * @sig {a: b} -> {a: *} -> {b: *}
+ * @param {!Object} keysMap
+ * @param {!Object} obj
+ * @return {!Object} New object with copied keys
+ * @see {@link RA.renameKeys|renameKeys}
+ * @example
+ *
+ * copyKeys({ a: 'b' }, { a: true }); //=> { a: true, b: true }
+ * copyKeys({ a: 'b' }, { a: true, b: false }); //=> { a: true, b: true }
+ */
+const copyKeys = curryN(2, (keysMap, obj) => ({
+  ...obj,
+  ...renameKeys(keysMap, obj),
+}));
+
+export default copyKeys;

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/index.js

@@ -91,6 +91,7 @@ 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';
@@ -107,12 +108,13 @@ 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';
 export { default as delayP } from './delayP';
 export { default as thenP } from './thenP';
-export { default as then } from './thenP';
+export { default as then } from './thenP'; // eslint-disable-line no-restricted-exports
 export { default as thenCatchP } from './thenCatchP';
 export { default as allSettledP } from './allSettledP';
 export { default as Y } from './Y';
@@ -169,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';
@@ -222,6 +225,7 @@ export { default as toInteger32 } from './toInteger32';
 export { default as toInt32 } from './toInteger32'; // alias of toInteger32
 export { default as toUinteger32 } from './toUinteger32';
 export { default as toUint32 } from './toUinteger32'; // alias of to toUinteger32
+export { default as toNumber } from './toNumber';
 // String
 export { default as replaceAll } from './replaceAll';
 export { default as escapeRegExp } from './escapeRegExp';

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/isCoercible.js

@@ -0,0 +1,12 @@
+import { both, hasIn } from 'ramda';
+
+import isObj from '../isObj';
+import isSymbol from '../isSymbol';
+import neither from '../neither';
+
+const isCoercible = neither(
+  isSymbol,
+  both(isObj, neither(hasIn('toString'), hasIn('valueOf')))
+);
+
+export default isCoercible;

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/internal/ponyfills/Promise.any.js

@@ -3,7 +3,7 @@ import { map } from 'ramda';
 import resolveP from '../../resolveP';
 
 export class AggregatedError extends Error {
-  constructor(errors = [], message) {
+  constructor(errors = [], message = '') {
     super(message);
 
     this.errors = errors;

package/src/isNotNilOrEmpty.js

@@ -3,7 +3,7 @@ import { complement } from 'ramda';
 import isNilOrEmpty from './isNilOrEmpty';
 
 /**
- * Returns `true` if the given value is its type's empty value, `null` or `undefined`.
+ * Returns `false` if the given value is its type's empty value, `null` or `undefined`.
  *
  * @func isNotNilOrEmpty
  * @memberOf RA

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/toNumber.js

@@ -0,0 +1,24 @@
+import { ifElse, always } from 'ramda';
+
+import isCoercible from './internal/isCoercible';
+
+/**
+ * Converts value to a number.
+ *
+ * @func toNumber
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.36.0|v2.36.0}
+ * @category Type
+ * @param {*} val The value to convert
+ * @return {Number}
+ * @example
+ *
+ * RA.toNumber(3.2); //=> 3.2
+ * RA.toNumber(Number.MIN_VALUE); //=> 5e-324
+ * RA.toNumber(Infinity); //=> Infinity
+ * RA.toNumber('3.2'); //=> 3.2
+ * RA.toNumber(Symbol('3.2')); //=> NaN
+ */
+const toNumber = ifElse(isCoercible, Number, always(NaN));
+
+export default toNumber;

package/types/index.d.ts

@@ -455,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`.
          */
@@ -588,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.
@@ -996,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
@@ -1516,6 +1538,11 @@ declare namespace RamdaAdjunct {
         toUinteger32(val: number): number;
         toUint32(val: number): number; // alias
 
+        /**
+         * Converts value to a number.
+         */
+        toNumber(val: any): number;
+
         /**
          * Creates an array of numbers (positive and/or negative) progressing from start up to, but not including, end.
          *