ramda-adjunct 2.35.0 → 3.1.0

package/package.json

@@ -14,7 +14,7 @@
     "cookbook",
     "functional"
   ],
-  "version": "2.35.0",
+  "version": "3.1.0",
   "homepage": "https://github.com/char0n/ramda-adjunct",
   "license": "BSD-3-Clause",
   "repository": {
@@ -93,22 +93,8 @@
       }
     },
     "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: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",
-    "test:ramda0.20.1": "npm install ramda@0.20.1 && npm test",
-    "test:ramda0.21.0": "npm install ramda@0.21.0 && npm test",
-    "test:ramda0.22.0": "npm install ramda@0.22.0 && npm test",
-    "test:ramda0.22.1": "npm install ramda@0.22.1 && npm test",
-    "test:ramda0.23.0": "npm install ramda@0.23.0 && npm test",
-    "test:ramda0.24.0": "npm install ramda@0.24.0 && npm test",
-    "test:ramda0.24.1": "npm install ramda@0.24.1 && npm test",
-    "test:ramda0.25.0": "npm install ramda@0.25.0 && npm test",
-    "test:ramda0.26.0": "npm install ramda@0.26.0 && npm test",
-    "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:ramda": "bnr test:ramda0.28.0",
+    "test:ramda0.28.0": "npm install ramda@0.28.0 && npm test",
     "test:bundle-create": "webpack --config webpack.config-test.web.js --progress",
     "test:bundle-clean": "rimraf tmp-test-bundle.js",
     "coverage": {
@@ -134,65 +120,64 @@
     "prepublishOnly": "npm run clean && npm run lint && npm run test && npm run build && npm run docs",
     "clean": "rimraf .nyc_output .tmp docs coverage tmp-test-bundle.js dist lib es"
   },
-  "readme": "README.md",
   "peerDependencies": {
-    "ramda": ">= 0.19.0 <= 0.27.1"
+    "ramda": ">= 0.28.0 <= 0.28.0"
   },
   "devDependencies": {
-    "@babel/cli": "7.15.7",
-    "@babel/core": "=7.15.8",
-    "@babel/plugin-transform-modules-commonjs": "7.15.4",
-    "@babel/preset-env": "=7.15.8",
-    "@babel/register": "7.15.3",
-    "@commitlint/cli": "=13.2.1",
-    "@commitlint/config-conventional": "=13.2.0",
+    "@babel/cli": "7.17.6",
+    "@babel/core": "=7.17.9",
+    "@babel/plugin-transform-modules-commonjs": "=7.17.9",
+    "@babel/preset-env": "=7.16.11",
+    "@babel/register": "7.17.7",
+    "@commitlint/cli": "=16.2.3",
+    "@commitlint/config-conventional": "=16.2.1",
     "assert": "=2.0.0",
-    "babel-loader": "8.2.3",
+    "babel-loader": "=8.2.5",
     "babel-plugin-annotate-pure-calls": "0.4.0",
     "babel-plugin-istanbul": "6.1.1",
     "better-npm-run": "0.1.1",
-    "chai": "4.3.4",
+    "chai": "4.3.6",
     "codecov": "3.8.3",
-    "conventional-changelog-cli": "2.1.1",
-    "core-js": "=3.19.0",
+    "conventional-changelog-cli": "2.2.2",
+    "core-js": "=3.21.1",
     "docdash": "git+https://github.com/char0n/docdash.git#534b44382138a55dd8d93642c979e51e46471185",
-    "dtslint": "=4.2.0",
-    "eslint": "7.32.0",
-    "eslint-config-airbnb-base": "14.2.1",
-    "eslint-config-prettier": "=8.3.0",
-    "eslint-plugin-import": "=2.25.2",
-    "eslint-plugin-mocha": "9.0.0",
+    "dtslint": "=4.2.1",
+    "eslint": "=8.14.0",
+    "eslint-config-airbnb-base": "=15.0.0",
+    "eslint-config-prettier": "=8.5.0",
+    "eslint-plugin-import": "=2.26.0",
+    "eslint-plugin-mocha": "=10.0.4",
     "eslint-plugin-prettier": "4.0.0",
     "eslint-plugin-ramda": "2.5.1",
     "fantasy-land": "5.0.0",
-    "fantasy-laws": "=1.2.0",
+    "fantasy-laws": "=2.0.1",
     "folktale": "=2.3.2",
-    "glob": "7.2.0",
+    "glob": "=8.0.1",
     "husky": "7.0.4",
     "istanbul": "=0.4.5",
-    "jsdoc": "=3.6.7",
+    "jsdoc": "=3.6.10",
     "jsverify": "0.8.4",
     "license-cli": "1.1.6",
-    "lint-staged": "11.2.6",
-    "mocha": "=9.1.3",
+    "lint-staged": "12.3.7",
+    "mocha": "=9.2.2",
     "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.4.1",
+    "prettier": "=2.6.2",
     "process": "=0.11.10",
-    "ramda": "0.27.1",
+    "ramda": "=0.28.0",
     "ramda-fantasy": "=0.8.0",
     "regenerator-runtime": "=0.13.9",
     "rimraf": "3.0.2",
-    "sanctuary-show": "2.0.0",
-    "sinon": "=11.1.2",
-    "terser-webpack-plugin": "5.2.4",
+    "sanctuary-show": "3.0.0",
+    "sinon": "=13.0.2",
+    "terser-webpack-plugin": "5.3.1",
     "testem": "=3.6.0",
     "tslint": "=6.1.3",
-    "typescript": "=4.4.4",
-    "webpack": "=5.61.0",
-    "webpack-cli": "4.9.1"
+    "typescript": "=4.6.3",
+    "webpack": "=5.72.0",
+    "webpack-cli": "4.9.2"
   },
   "browserslist": "> 0.25%, ie 10, ie 11, not op_mini all",
   "tonicExampleFilename": "tonicExample.js",

package/src/flattenPath.js

@@ -1,4 +1,4 @@
-import { pathOr, curry, merge } from 'ramda';
+import { pathOr, curry, mergeRight } from 'ramda';
 
 /**
  * Flattens a property path so that its fields are spread out into the provided object.
@@ -21,6 +21,8 @@ import { pathOr, curry, merge } from 'ramda';
  *   { a: 1, b1: { b2: { c: 3, d: 4 } } }
  * ); // => { a: 1, c: 3, d: 4, b1: { b2: { c: 3, d: 4 } } };
  */
-const flattenPath = curry((path, obj) => merge(obj, pathOr({}, path, obj)));
+const flattenPath = curry((path, obj) =>
+  mergeRight(obj, pathOr({}, path, obj))
+);
 
 export default flattenPath;

package/src/included.js

@@ -0,0 +1,28 @@
+import { flip, includes } from 'ramda';
+
+/**
+ * Returns true if the specified value is equal, in R.equals terms,
+ * to at least one element of the given list or false otherwise.
+ * Given list can be a string.
+ *
+ * Like {@link http://ramdajs.com/docs/#includes|R.includes} but with argument order reversed.
+ *
+ * @func included
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/3.0.0|v3.0.0}
+ * @category List
+ * @sig [a] -> a -> Boolean
+ * @param {Array|String} list The list to consider
+ * @param {*} a The item to compare against
+ * @return {boolean} Returns Boolean `true` if an equivalent item is in the list or `false` otherwise
+ * @see {@link http://ramdajs.com/docs/#includes|R.includes}
+ * @example
+ *
+ * RA.included([1, 2, 3], 3); //=> true
+ * RA.included([1, 2, 3], 4); //=> false
+ * RA.included([{ name: 'Fred' }], { name: 'Fred' }); //=> true
+ * RA.included([[42]], [42]); //=> true
+ */
+const included = flip(includes);
+
+export default included;

package/src/index.js

@@ -29,7 +29,7 @@ export { default as isNotAsyncFunction } from './isNotAsyncFunction';
 export { default as isFunction } from './isFunction';
 export { default as isNotFunction } from './isNotFunction';
 export { default as isObj } from './isObj';
-export { default as isObject } from './isObj'; // alias of isObject
+export { default as isObject } from './isObj'; // alias of isObj
 export { default as isNotObj } from './isNotObj';
 export { default as isNotObject } from './isNotObj'; // alias of isNotObj
 export { default as isObjLike } from './isObjLike';
@@ -39,7 +39,7 @@ export { default as isNotObjectLike } from './isNotObjLike'; // alias of isNotOb
 export { default as isPlainObj } from './isPlainObj';
 export { default as isPlainObject } from './isPlainObj';
 export { default as isNotPlainObj } from './isNotPlainObj';
-export { default as isNotPlainObject } from './isNotPlainObj'; // alias of isNotPlainObject
+export { default as isNotPlainObject } from './isNotPlainObj'; // alias of isNotPlainObj
 export { default as isDate } from './isDate';
 export { default as isNotDate } from './isNotDate';
 export { default as isValidDate } from './isValidDate';
@@ -92,6 +92,7 @@ export { default as isNaturalNumber } from './isNaturalNumber';
 export { default as isPrimitive } from './isPrimitive';
 export { default as isNotPrimitive } from './isNotPrimitive';
 export { default as isSentinelValue } from './isSentinelValue';
+export { default as isBlank } from './isBlank';
 // Function
 export { default as stubUndefined } from './stubUndefined';
 export { default as stubNull } from './stubNull';
@@ -113,8 +114,6 @@ 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 thenCatchP } from './thenCatchP';
 export { default as allSettledP } from './allSettledP';
 export { default as Y } from './Y';
@@ -142,8 +141,7 @@ export { default as sliceTo } from './sliceTo';
 export { default as omitIndexes } from './omitIndexes';
 export { default as compact } from './compact';
 export { default as appendFlipped } from './appendFlipped';
-export { default as contained } from './contained';
-export { default as included } from './contained';
+export { default as included } from './included';
 export { default as move } from './move';
 export { default as lengthGt } from './lengthGt';
 export { default as lengthLt } from './lengthLt';
@@ -161,6 +159,7 @@ export { default as toArray } from './toArray';
 export { default as allUnique } from './allUnique';
 export { default as notAllUnique } from './notAllUnique';
 export { default as sortByProps } from './sortByProps';
+export { default as sortByPaths } from './sortByPaths';
 export { default as skipTake } from './skipTake';
 export { default as rangeStep } from './rangeStep';
 export { default as findOr } from './findOr';
@@ -172,9 +171,6 @@ 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';
 export { default as mergeProps } from './mergeProps';
 export { default as mergePaths } from './mergePaths';
 export { default as mergeProp } from './mergeProp';
@@ -182,7 +178,6 @@ export { default as mergePath } from './mergePath';
 export { default as omitBy } from './omitBy';
 export { default as pathOrLazy } from './pathOrLazy';
 export { default as viewOr } from './viewOr';
-export { default as hasPath } from './hasPath';
 export { default as spreadProp } from './spreadProp';
 export { default as spreadPath } from './spreadPath';
 export { default as flattenProp } from './flattenProp';
@@ -225,6 +220,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/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.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/isBlank.js

@@ -0,0 +1,33 @@
+import { isEmpty, isNil, anyPass, test } from 'ramda';
+
+import isFalse from './isFalse';
+/**
+ * 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/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/mergePath.js

@@ -1,6 +1,4 @@
-import { curry, over, lensPath } from 'ramda';
-
-import mergeRight from './mergeRight';
+import { curry, over, lensPath, mergeLeft } from 'ramda';
 
 /**
  * Create a new object with the own properties of the object under the `path`
@@ -26,7 +24,7 @@ import mergeRight from './mergeRight';
  * ); //=> { outer: { inner: { foo: 3, bar: 4 } }
  */
 const mergePath = curry((path, source, obj) =>
-  over(lensPath(path), mergeRight(source), obj)
+  over(lensPath(path), mergeLeft(source), obj)
 );
 
 export default mergePath;

package/src/omitIndexes.js

@@ -1,8 +1,8 @@
-import { contains, curry, addIndex, reject } from 'ramda';
+import { includes, curry, addIndex, reject } from 'ramda';
 
 // helpers
 const rejectIndexed = addIndex(reject);
-const containsIndex = curry((indexes, val, index) => contains(index, indexes));
+const containsIndex = curry((indexes, val, index) => includes(index, indexes));
 
 /**
  * Returns a partial copy of an array omitting the indexes specified.

package/src/pickIndexes.js

@@ -1,8 +1,8 @@
-import { filter, addIndex, curry, contains } from 'ramda';
+import { filter, addIndex, curry, includes } from 'ramda';
 
 // helpers
 const filterIndexed = addIndex(filter);
-const containsIndex = curry((indexes, val, index) => contains(index, indexes));
+const containsIndex = curry((indexes, val, index) => includes(index, indexes));
 
 /**
  * Picks values from list by indexes.

package/src/sortByPaths.js

@@ -0,0 +1,55 @@
+import { ascend, identity, map, path, pipe, sortWith, useWith } from 'ramda';
+
+const pathToAscendSort = pipe(path, ascend);
+const mapPathsToAscendSort = map(pathToAscendSort);
+
+/**
+ * Sort a list of objects by a list of paths (if first path value is equivalent, sort by second, etc).
+ *
+ * @func sortByPaths
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/3.1.0|v3.1.0}
+ * @category List
+ * @sig [[k]] -> [{k: v}] -> [{k: v}]
+ * @param {Array.<Array.<string>>} paths A list of paths in the list param to sort by
+ * @param {Array.<object>} list A list of objects to be sorted
+ * @return {Array.<object>} A new list sorted by the paths in the paths param
+ * @example
+ *
+ * const alice = {
+ *   name: 'Alice',
+ *   address: {
+ *     street: 31,
+ *     zipCode: 97777,
+ *   },
+ * };
+ * const bob = {
+ *   name: 'Bob',
+ *   address: {
+ *     street: 31,
+ *     zipCode: 55555,
+ *   },
+ * };
+ * const clara = {
+ *   name: 'Clara',
+ *   address: {
+ *     street: 32,
+ *     zipCode: 90210,
+ *   },
+ * };
+ * const people = [clara, bob, alice]
+ *
+ * RA.sortByPaths([
+ *   ['address', 'street'],
+ *   ['address', 'zipCode'],
+ * ], people); // => [bob, alice, clara]
+ *
+ * RA.sortByPaths([
+ *   ['address', 'zipCode'],
+ *   ['address', 'street'],
+ * ], people); // => [bob, clara, alice]
+ */
+
+const sortByPaths = useWith(sortWith, [mapPathsToAscendSort, identity]);
+
+export default sortByPaths;

package/src/spreadPath.js

@@ -1,4 +1,4 @@
-import { curryN, converge, merge, dissocPath, pathOr } from 'ramda';
+import { curryN, converge, mergeRight, dissocPath, pathOr } from 'ramda';
 
 /**
  * Spreads object under property path onto provided object.
@@ -21,6 +21,6 @@ import { curryN, converge, merge, dissocPath, pathOr } from 'ramda';
  *   { a: 1, b1: { b2: { c: 3, d: 4 } } }
  * ); // => { a: 1, c: 3, d: 4, b1: {} };
  */
-const spreadPath = curryN(2, converge(merge, [dissocPath, pathOr({})]));
+const spreadPath = curryN(2, converge(mergeRight, [dissocPath, pathOr({})]));
 
 export default spreadPath;

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/src/trimCharsEnd.js

@@ -1,6 +1,6 @@
 import { curry, dropLastWhile, join, pipe, split } from 'ramda';
 
-import contained from './contained';
+import included from './included';
 
 /**
  * Removes specified characters from the end of a string.
@@ -19,7 +19,7 @@ import contained from './contained';
  */
 
 const trimCharsEnd = curry((chars, value) =>
-  pipe(split(''), dropLastWhile(contained(chars)), join(''))(value)
+  pipe(split(''), dropLastWhile(included(chars)), join(''))(value)
 );
 
 export default trimCharsEnd;

package/src/trimCharsStart.js

@@ -1,6 +1,6 @@
 import { curry, dropWhile, join, pipe, split } from 'ramda';
 
-import contained from './contained';
+import included from './included';
 
 /**
  * Removes specified characters from the beginning of a string.
@@ -19,7 +19,7 @@ import contained from './contained';
  */
 
 const trimCharsStart = curry((chars, value) =>
-  pipe(split(''), dropWhile(contained(chars)), join(''))(value)
+  pipe(split(''), dropWhile(included(chars)), join(''))(value)
 );
 
 export default trimCharsStart;

package/types/index.d.ts

@@ -370,6 +370,12 @@ declare namespace RamdaAdjunct {
          */
         isBigInt(val: any): boolean;
 
+        /**
+         * Returns `true` if the given value is its type's empty value, `false`, `undefined`
+         * as well as strings containing only whitespace characters; `false` otherwise.
+         */
+        isBlank(val: any): boolean;
+
         /**
          * Checks whether the passed value is a `float`.
          */
@@ -629,19 +635,6 @@ declare namespace RamdaAdjunct {
             (key: string): (obj: object) => object;
         };
 
-        /**
-         * Create a new object with the own properties of the second object merged with
-         * the own properties of the first object. If a key exists in both objects,
-         * the value from the first object will be used. *
-         * Putting it simply: it sets properties only if they don't exist.
-         */
-        mergeRight(source: object, destination: object): object;
-        mergeRight(source: object): (destination: object) => object;
-        mergeLeft(source: object, destination: object): object; // alias
-        mergeLeft(source: object): (destination: object) => object; // alias
-        resetToDefault(defaultOptions: object, options: object): object; // alias of mergeRight
-        resetToDefault(defaultOptions: object): (options: object) => object; // alias of mergeRight
-
         /**
          * Functional equivalent of merging object properties with object spread.
          */
@@ -901,12 +894,6 @@ declare namespace RamdaAdjunct {
             (high: number): (value: number) => boolean;
         };
 
-        /**
-         * Returns whether or not an object has an own property with the specified name at a given path.
-         */
-        hasPath(path: Array<string | number>, obj: object): boolean;
-        hasPath(path: Array<string | number>): (obj: object) => boolean;
-
         /**
          * Spreads object under property path onto provided object.
          */
@@ -1018,16 +1005,6 @@ declare namespace RamdaAdjunct {
         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
-         * and the promise instance itself.
-         */
-        thenP<T>(onFulfilled: Function, thenable: Promise<T>): Promise<T>;
-        thenP<T>(onFulfilled: Function): (thenable: Promise<T>) => Promise<T>;
-        then<T>(onFulfilled: Function, thenable: Promise<T>): Promise<T>;
-        then<T>(onFulfilled: Function): (thenable: Promise<T>) => Promise<T>;
-
         /**
          * Composable shortcut for `Promise.then` that allows for success and failure call backs.
          * The thenCatchP function returns a Promise. It takes three arguments: a callback function for the success of the Promise,
@@ -1323,12 +1300,10 @@ declare namespace RamdaAdjunct {
          * to at least one element of the given list or false otherwise.
          * Given list can be a string.
          *
-         * Like {@link http://ramdajs.com/docs/#contains|R.contains} but with argument order reversed.
+         * Like {@link http://ramdajs.com/docs/#contains|R.includes} but with argument order reversed.
          */
-        contained<T>(list: T[], val: T): boolean;
-        contained<T>(list: T[]): (val: T) => boolean;
-        included<T>(list: T[], val: T): boolean; // alias
-        included<T>(list: T[]): (val: T) => boolean; // alias
+        included<T>(list: T[], val: T): boolean;
+        included<T>(list: T[]): (val: T) => boolean;
 
         /**
          * Can be used as a way to compose multiple invokers together to form polymorphic functions,
@@ -1508,6 +1483,12 @@ declare namespace RamdaAdjunct {
         skipTake<T>(n: number, list: T[]): T[];
         skipTake<T>(n: number): (list: T[]) => T[];
 
+        /**
+         * Sort a list of objects by a list of paths (if first path value is equivalent, sort by second, etc).
+         */
+        sortByPaths(props: string[][], list: object[]): object[];
+        sortByPaths(props: string[][]): (list: object[]) => object[];
+
         /**
          * Determine if input value is an indexed data type.
          */
@@ -1538,6 +1519,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.
          *

package/es/contained.js

@@ -1,29 +0,0 @@
-import { flip, contains } from 'ramda';
-/**
- * Returns true if the specified value is equal, in R.equals terms,
- * to at least one element of the given list or false otherwise.
- * Given list can be a string.
- *
- * Like {@link http://ramdajs.com/docs/#contains|R.contains} but with argument order reversed.
- *
- * @func contained
- * @aliases included
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
- * @deprecated since v2.12.0; please use RA.included alias
- * @category List
- * @sig [a] -> a -> Boolean
- * @param {Array|String} list The list to consider
- * @param {*} a The item to compare against
- * @return {boolean} Returns Boolean `true` if an equivalent item is in the list or `false` otherwise
- * @see {@link http://ramdajs.com/docs/#contains|R.contains}
- * @example
- *
- * RA.contained([1, 2, 3], 3); //=> true
- * RA.contained([1, 2, 3], 4); //=> false
- * RA.contained([{ name: 'Fred' }], { name: 'Fred' }); //=> true
- * RA.contained([[42]], [42]); //=> true
- */
-
-var contained = flip(contains);
-export default contained;