ramda-adjunct 2.33.0 → 3.0.0

package/package.json

@@ -14,7 +14,7 @@
     "cookbook",
     "functional"
   ],
-  "version": "2.33.0",
+  "version": "3.0.0",
   "homepage": "https://github.com/char0n/ramda-adjunct",
   "license": "BSD-3-Clause",
   "repository": {
@@ -78,6 +78,7 @@
     "build:es": "better-npm-run build:es",
     "build:commonjs": "better-npm-run build:commonjs",
     "build:umd": "better-npm-run build:umd",
+    "prepublishOnly": "better-npm-run prepublishOnly",
     "clean": "better-npm-run clean"
   },
   "betterScripts": {
@@ -92,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": {
@@ -133,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.14.3",
-    "@babel/core": "=7.14.3",
-    "@babel/plugin-transform-modules-commonjs": "7.14.0",
-    "@babel/preset-env": "=7.14.2",
-    "@babel/register": "7.13.16",
-    "@commitlint/cli": "=12.1.4",
-    "@commitlint/config-conventional": "=12.1.4",
+    "@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.2",
-    "conventional-changelog-cli": "2.1.1",
-    "core-js": "=3.12.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.26.0",
-    "eslint-config-airbnb-base": "14.2.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.23.2",
-    "eslint-plugin-mocha": "8.1.0",
-    "eslint-plugin-prettier": "3.4.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": "5.0.0",
     "fantasy-laws": "=1.2.0",
     "folktale": "=2.3.2",
-    "glob": "7.1.7",
-    "husky": "6.0.0",
+    "glob": "7.2.0",
+    "husky": "7.0.4",
     "istanbul": "=0.4.5",
     "jsdoc": "=3.6.7",
     "jsverify": "0.8.4",
     "license-cli": "1.1.6",
-    "lint-staged": "11.0.0",
-    "mocha": "=8.4.0",
-    "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.3.0",
+    "prettier": "=2.5.1",
     "process": "=0.11.10",
-    "ramda": "0.27.1",
+    "ramda": "=0.28.0",
     "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.2",
-    "testem": "=3.4.1",
+    "sinon": "=11.1.2",
+    "terser-webpack-plugin": "5.3.0",
+    "testem": "=3.6.0",
     "tslint": "=6.1.3",
-    "typescript": "=4.2.4",
-    "webpack": "=5.37.1",
-    "webpack-cli": "4.7.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/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/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';
@@ -113,8 +113,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 +140,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';
@@ -171,9 +168,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 mergeRight } from './mergeRight';
-export { default as mergeLeft } from './mergeRight';
-export { default as resetToDefault } from './mergeRight';
+export { default as copyKeys } from './copyKeys';
 export { default as mergeProps } from './mergeProps';
 export { default as mergePaths } from './mergePaths';
 export { default as mergeProp } from './mergeProp';
@@ -181,7 +176,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';
@@ -224,6 +218,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/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/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

@@ -594,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.
@@ -621,19 +629,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.
          */
@@ -893,12 +888,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.
          */
@@ -1010,16 +999,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,
@@ -1315,12 +1294,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,
@@ -1530,6 +1507,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;

package/es/hasPath.js

@@ -1,38 +0,0 @@
-import { length, has, path, head, tail, curryN } from 'ramda';
-import isObj from './isObj';
-/**
- * Returns whether or not an object has an own property with the specified name at a given path.
- *
- * @func hasPath
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.14.0|v1.14.0}
- * @deprecated since v2.12.0; ramda@0.26.0 contains hasPath
- * @category Object
- * @typedef Idx = String | Int
- * @sig [Idx] -> {a} -> Boolean
- * @param {Array.<string|number>} path The path of the nested property
- * @param {Object} obj The object to test
- * @return {boolean}
- * @see {@link http://ramdajs.com/docs/#has|R.has}
- * @example
- *
- * RA.hasPath(['a', 'b'], { a: { b: 1 } }); //=> true
- * RA.hasPath(['a', 'b', 'c'], { a: { b: 1 } }); //=> false
- * RA.hasPath(['a', 'b'], { a: { } }); //=> false
- * RA.hasPath([0], [1, 2]); //=> true
- */
-
-var hasPath = curryN(2, function (objPath, obj) {
-  var prop = head(objPath); // termination conditions
-
-  if (length(objPath) === 0 || !isObj(obj)) {
-    return false;
-  }
-
-  if (length(objPath) === 1) {
-    return has(prop, obj);
-  }
-
-  return hasPath(tail(objPath), path([prop], obj)); // base case
-});
-export default hasPath;

package/es/mergeRight.js

@@ -1,26 +0,0 @@
-import { merge, flip } from 'ramda';
-/**
- * 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.
- *
- * @func mergeRight
- * @deprecated since v2.12.0; available in ramda@0.26.0 as R.mergeLeft
- * @aliases mergeLeft, resetToDefault
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.6.0|v1.6.0}
- * @category Object
- * @sig {k: v} -> {k: v} -> {k: v}
- * @param {Object} r Destination
- * @param {Object} l Source
- * @return {Object}
- * @see {@link http://ramdajs.com/docs/#merge|R.merge}, {@link https://github.com/ramda/ramda/wiki/Cookbook#set-properties-only-if-they-dont-exist|Ramda Cookbook}
- * @example
- *
- * RA.mergeRight({ 'age': 40 }, { 'name': 'fred', 'age': 10 });
- * //=> { 'name': 'fred', 'age': 40 }
- */
-
-var mergeRight = flip(merge);
-export default mergeRight;

package/es/thenP.js

@@ -1,28 +0,0 @@
-import { invoker } from 'ramda';
-/**
- * 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.
- *
- * @func thenP
- * @memberOf RA
- * @aliases then
- * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
- * @deprecated since v2.12.0; available in ramda@0.26.0 as R.then
- * @category Function
- * @sig (a -> Promise b | b) -> Promise b
- * @param {Function} onFulfilled A Function called if the Promise is fulfilled. This function has one argument, the fulfillment value
- * @param {Promise} promise Any Promise or Thenable object
- * @return {Promise} A Promise in the pending status
-
- * @see {@link RA.resolveP|resolveP}, {@link RA.rejectP|rejectP}, {@link RA.allP|allP}
- * @example
- *
- * const promise = Promise.resolve(1);
- * const add1 = v => v + 1;
- *
- * RA.thenP(add1, promise); // => Promise(2)
- */
-
-var thenP = invoker(1, 'then');
-export default thenP;