ramda-adjunct 2.34.0

package/es/reduceP.js

@@ -0,0 +1,111 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import { curryN, reduce, length } from 'ramda';
+import isUndefined from './isUndefined';
+import resolveP from './resolveP';
+import allP from './allP';
+/* eslint-disable max-len */
+
+/**
+ * Given an `Iterable`(arrays are `Iterable`), or a promise of an `Iterable`,
+ * which produces promises (or a mix of promises and values),
+ * iterate over all the values in the `Iterable` into an array and
+ * reduce the array to a value using the given iterator function.
+ *
+ * If the iterator function returns a promise, then the result of the promise is awaited,
+ * before continuing with next iteration. If any promise in the array is rejected or a promise
+ * returned by the iterator function is rejected, the result is rejected as well.
+ *
+ * If `initialValue` is `undefined` (or a promise that resolves to `undefined`) and
+ * the `Iterable` contains only 1 item, the callback will not be called and
+ * the `Iterable's` single item is returned. If the `Iterable` is empty, the callback
+ * will not be called and `initialValue` is returned (which may be undefined).
+ *
+ * This function is basically equivalent to {@link http://bluebirdjs.com/docs/api/promise.reduce.html|bluebird.reduce}.
+ *
+ * @func reduceP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|v1.13.0}
+ * @category List
+ * @typedef MaybePromise = Promise.<*> | *
+ * @sig ((Promise a, MaybePromise b) -> Promise a) -> MaybePromise a -> MaybePromise [MaybePromise b] -> Promise a
+ * @param {Function} fn The iterator function. Receives two values, the accumulator and the current element from the list
+ * @param {*|Promise.<*>} acc The accumulator value
+ * @param {Array.<*>|Promise.<Array<*|Promise.<*>>>} list The list to iterate over
+ * @return {Promise} The final, accumulated value
+ * @see {@link http://ramdajs.com/docs/#reduce|R.reduce}, {@link RA.reduceRightP|reduceRightP}, {@link http://bluebirdjs.com/docs/api/promise.reduce.html|bluebird.reduce}
+ * @example
+ *
+ * RA.reduceP(
+ *   (total, fileName) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   0,
+ *   ['file1.txt', 'file2.txt', 'file3.txt']
+ * ); // => Promise(10)
+ *
+ * RA.reduceP(
+ *   (total, fileName) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   Promise.resolve(0),
+ *   ['file1.txt', 'file2.txt', 'file3.txt']
+ * ); // => Promise(10)
+ *
+ * RA.reduceP(
+ *   (total, fileName) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   0,
+ *   [Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt']
+ * ); // => Promise(10)
+ *
+ * RA.reduceP(
+ *   (total, fileName) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   0,
+ *   Promise.resolve([Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt'])
+ * ); // => Promise(10)
+ *
+ */
+
+/* esline-enable max-len */
+
+var reduceP = curryN(3, function (fn, acc, list) {
+  return resolveP(list).then(function (iterable) {
+    var listLength = length(iterable);
+
+    if (listLength === 0) {
+      return acc;
+    }
+
+    var reducer = reduce(function (accP, currentValueP) {
+      return accP.then(function (previousValue) {
+        return allP([previousValue, currentValueP]);
+      }).then(function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 2),
+            previousValue = _ref2[0],
+            currentValue = _ref2[1];
+
+        if (isUndefined(previousValue) && listLength === 1) {
+          return currentValue;
+        }
+
+        return fn(previousValue, currentValue);
+      });
+    });
+    return reducer(resolveP(acc), iterable);
+  });
+});
+export default reduceP;

package/es/reduceRightP.js

@@ -0,0 +1,117 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import { curryN, pipe, equals, reduceRight, length, concat } from 'ramda';
+import isUndefined from './isUndefined';
+import resolveP from './resolveP';
+import allP from './allP'; // in older ramda versions the order of the arguments is flipped
+
+var flipArgs = pipe(reduceRight(concat, ''), equals('ba'))(['a', 'b']);
+/* eslint-disable max-len */
+
+/**
+ * Given an `Iterable`(arrays are `Iterable`), or a promise of an `Iterable`,
+ * which produces promises (or a mix of promises and values),
+ * iterate over all the values in the `Iterable` into an array and
+ * reduce the array to a value using the given iterator function.
+ *
+ * Similar to {@link RA.reduceP|reduceP} except moves through the input list from the right to the left.
+ * The iterator function receives two values: (value, acc),
+ * while the arguments' order of reduceP's iterator function is (acc, value).
+ *
+ * @func reduceRightP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|v1.13.0}
+ * @category List
+ * @typedef MaybePromise = Promise.<*> | *
+ * @sig ((MaybePromise b, Promise a) -> Promise a) -> MaybePromise a -> MaybePromise [MaybePromise b] -> Promise a
+ * @param {Function} fn The iterator function. Receives two values, the current element from the list and the accumulator
+ * @param {*|Promise.<*>} acc The accumulator value
+ * @param {Array.<*>|Promise.<Array<*|Promise.<*>>>} list The list to iterate over
+ * @return {Promise} The final, accumulated value
+ * @see {@link RA.reduceP|reduceP}, {@link http://bluebirdjs.com/docs/api/promise.reduce.html|bluebird.reduce}
+ * @example
+ *
+ * RA.reduceRightP(
+ *   (fileName, total) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   0,
+ *   ['file1.txt', 'file2.txt', 'file3.txt']
+ * ); // => Promise(10)
+ *
+ * RA.reduceRightP(
+ *   (fileName, total) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   Promise.resolve(0),
+ *   ['file1.txt', 'file2.txt', 'file3.txt']
+ * ); // => Promise(10)
+ *
+ * RA.reduceRightP(
+ *   (fileName, total) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   0,
+ *   [Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt']
+ * ); // => Promise(10)
+ *
+ * RA.reduceRightP(
+ *   (fileName, total) => fs
+ *     .readFileAsync(fileName, 'utf8')
+ *     .then(contents => total + parseInt(contents, 10)),
+ *   0,
+ *   Promise.resolve([Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt'])
+ * ); // => Promise(10)
+ *
+ */
+
+/* esline-enable max-len */
+
+var reduceRightP = curryN(3, function (fn, acc, list) {
+  return resolveP(list).then(function (iterable) {
+    var listLength = length(iterable);
+
+    if (listLength === 0) {
+      return acc;
+    }
+
+    var reducer = reduceRight(function (arg1, arg2) {
+      var accP;
+      var currentValueP;
+
+      if (flipArgs) {
+        accP = arg1;
+        currentValueP = arg2;
+      } else {
+        accP = arg2;
+        currentValueP = arg1;
+      }
+
+      return accP.then(function (previousValue) {
+        return allP([previousValue, currentValueP]);
+      }).then(function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 2),
+            previousValue = _ref2[0],
+            currentValue = _ref2[1];
+
+        if (isUndefined(previousValue) && listLength === 1) {
+          return currentValue;
+        }
+
+        return fn(currentValue, previousValue);
+      });
+    });
+    return reducer(resolveP(acc), iterable);
+  });
+});
+export default reduceRightP;

package/es/rejectP.js

@@ -0,0 +1,23 @@
+import { bind } from 'ramda';
+/**
+ * Composable shortcut for `Promise.reject`.
+ *
+ * Returns a Promise object that is rejected with the given reason.
+ *
+ * @func rejectP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.16.0|v1.16.0}
+ * @category Function
+ * @sig a -> Promise a
+ * @param {*} [reason=undefined] Reason why this Promise rejected
+ * @return {Promise} A Promise that is rejected with the given reason
+ * @see {@link RA.resolveP|resolveP}
+ * @example
+ *
+ * RA.rejectP(); //=> Promise(undefined)
+ * RA.rejectP('a'); //=> Promise('a')
+ * RA.rejectP([1, 2, 3]); //=> Promise([1, 2, 3])
+ */
+
+var rejectP = bind(Promise.reject, Promise);
+export default rejectP;

package/es/renameKeyWith.js

@@ -0,0 +1,28 @@
+import { curry, equals, when } from 'ramda';
+import renameKeysWith from './renameKeysWith';
+/**
+ * Creates a new object with the own properties of the provided object, but the
+ * key `key` renamed according to logic of renaming function.
+ *
+ * Keep in mind that in case the new key name already existed on the object,
+ * the behaviour is undefined and the result may vary between various JS engines!
+ *
+ * @func renameKeyWith
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.29.0|v2.29.0}
+ * @category Object
+ * @sig (k -> k) -> k -> {k: v} -> {k: v}
+ * @param {Function} fn Function that renames the keys
+ * @param {!string} key Key to rename
+ * @param {!Object} obj Provided object
+ * @return {!Object} New object with renamed key
+ * @see {@link RA.renameKeysWith|renameKeysWith}
+ * @example
+ *
+ * RA.renameKeyWith(R.concat('a'), 'A', { A: 1 }) //=> { aA: 1 }
+ */
+
+var renameKeyWith = curry(function (fn, key, obj) {
+  return renameKeysWith(when(equals(key), fn), obj);
+});
+export default renameKeyWith;

package/es/renameKeys.js

@@ -0,0 +1,42 @@
+import { curry, has } from 'ramda';
+import renameKeysWith from './renameKeysWith';
+
+var valueOrKey = function valueOrKey(keysMap) {
+  return function (key) {
+    if (has(key, keysMap)) {
+      return keysMap[key];
+    }
+
+    return key;
+  };
+};
+/**
+ * Creates a new object with the own properties of the provided object, but the
+ * keys renamed according to the keysMap object as `{oldKey: newKey}`.
+ * When some key is not found in the keysMap, then it's passed as-is.
+ *
+ * Keep in mind that in the case of keys conflict is behaviour undefined and
+ * the result may vary between various JS engines!
+ *
+ * @func renameKeys
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.5.0|v1.5.0}
+ * @category Object
+ * @sig {a: b} -> {a: *} -> {b: *}
+ * @param {!Object} keysMap
+ * @param {!Object} obj
+ * @return {!Object} New object with renamed keys
+ * @see {@link https://github.com/ramda/ramda/wiki/Cookbook#rename-keys-of-an-object|Ramda Cookbook}, {@link RA.renameKeysWith|renameKeysWith}
+ * @example
+ *
+ * const input = { firstName: 'Elisia', age: 22, type: 'human' };
+ *
+ * RA.renameKeys({ firstName: 'name', type: 'kind', foo: 'bar' })(input);
+ * //=> { name: 'Elisia', age: 22, kind: 'human' }
+ */
+
+
+var renameKeys = curry(function (keysMap, obj) {
+  return renameKeysWith(valueOrKey(keysMap), obj);
+});
+export default renameKeys;

package/es/renameKeysWith.js

@@ -0,0 +1,26 @@
+import { curry, toPairs, pipe, map, over, lensIndex, fromPairs } from 'ramda';
+/**
+ * Creates a new object with the own properties of the provided object, but the
+ * keys renamed according to logic of renaming function.
+ *
+ * Keep in mind that in the case of keys conflict is behaviour undefined and
+ * the result may vary between various JS engines!
+ *
+ * @func renameKeysWith
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.5.0|v1.5.0}
+ * @category Object
+ * @sig (a -> b) -> {a: *} -> {b: *}
+ * @param {Function} fn Function that renames the keys
+ * @param {!Object} obj Provided object
+ * @return {!Object} New object with renamed keys
+ * @see {@link https://github.com/ramda/ramda/wiki/Cookbook#rename-keys-of-an-object-by-a-function|Ramda Cookbook}, {@link RA.renameKeys|renameKeys}
+ * @example
+ *
+ * RA.renameKeysWith(R.concat('a'), { A: 1, B: 2, C: 3 }) //=> { aA: 1, aB: 2, aC: 3 }
+ */
+
+var renameKeysWith = curry(function (fn, obj) {
+  return pipe(toPairs, map(over(lensIndex(0), fn)), fromPairs)(obj);
+});
+export default renameKeysWith;

package/es/repeatStr.js

@@ -0,0 +1,24 @@
+import { curry, invoker, flip } from 'ramda';
+import ponyfill from './internal/ponyfills/String.repeat';
+import isFunction from './isFunction';
+export var repeatStrPonyfill = curry(ponyfill);
+export var repeatStrInvoker = flip(invoker(1, 'repeat'));
+/**
+ * Constructs and returns a new string which contains the specified
+ * number of copies of the string on which it was called, concatenated together.
+ *
+ * @func repeatStr
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.11.0|v2.11.0}
+ * @category List
+ * @sig String -> Number -> String
+ * @param {string} value String value to be repeated
+ * @param {number} count An integer between 0 and +∞: [0, +∞), indicating the number of times to repeat the string in the newly-created string that is to be returned
+ * @return {string} A new string containing the specified number of copies of the given string
+ * @example
+ *
+ * RA.repeatStr('a', 3); //=> 'aaa'
+ */
+
+var repeatStr = isFunction(String.prototype.repeat) ? repeatStrInvoker : repeatStrPonyfill;
+export default repeatStr;

package/es/replaceAll.js

@@ -0,0 +1,29 @@
+import { curryN, invoker } from 'ramda';
+import isFunction from './isFunction';
+import ponyfill from './internal/ponyfills/String.replaceAll';
+export var replaceAllPonyfill = curryN(3, ponyfill);
+export var replaceAllInvoker = invoker(2, 'replaceAll');
+/**
+ * Replaces all substring matches in a string with a replacement.
+ *
+ * @func replaceAll
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.17.0|v2.17.0}
+ * @category String
+ * @sig String -> String -> String -> String
+ * @param {string} searchValue The substring or a global RegExp to match
+ * @param {string} replaceValue The string to replace the matches with
+ * @param {string} str The String to do the search and replacement in
+ * @return {string} A new string containing all the `searchValue` replaced with the `replaceValue`
+ * @throws {TypeError} When invalid arguments provided
+ * @see {@link http://ramdajs.com/docs/#replace|R.replace}, {@link https://github.com/tc39/proposal-string-replaceall|TC39 proposal}
+ * @example
+ *
+ * RA.replaceAll('ac', 'ef', 'ac ab ac ab'); //=> 'ef ab ef ab'
+ * RA.replaceAll('', '_', 'xxx'); //=> '_x_x_x_'
+ * RA.replaceAll(/x/g, 'v', 'xxx'); //=> 'vvv'
+ * RA.replaceAll(/x/, 'v', 'xxx'); //=> TypeError
+ */
+
+var replaceAll = isFunction(String.prototype.replaceAll) ? replaceAllInvoker : replaceAllPonyfill;
+export default replaceAll;

package/es/resolveP.js

@@ -0,0 +1,29 @@
+import { bind } from 'ramda';
+/* eslint-disable max-len */
+
+/**
+ * Composable shortcut for `Promise.resolve`.
+ *
+ * Returns a Promise object that is resolved with the given value.
+ * If the value is a thenable (i.e. has a "then" method), the returned promise will
+ * "follow" that thenable, adopting its eventual state.
+ *
+ * @func resolveP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.16.0|v1.16.0}
+ * @category Function
+ * @sig a -> Promise a
+ * @param {*} [value=undefined] Argument to be resolved by this Promise. Can also be a Promise or a thenable to resolve
+ * @return {Promise} A Promise that is resolved with the given value, or the promise passed as value, if the value was a promise object
+ * @see {@link RA.rejectP|rejectP}
+ * @example
+ *
+ * RA.resolveP(); //=> Promise(undefined)
+ * RA.resolveP('a'); //=> Promise('a')
+ * RA.resolveP([1, 2, 3]); //=> Promise([1, 2, 3])
+ */
+
+/* eslint-enable max-len */
+
+var resolveP = bind(Promise.resolve, Promise);
+export default resolveP;

package/es/round.js

@@ -0,0 +1,24 @@
+import { bind, curryN } from 'ramda';
+/**
+ * Returns the value of a number rounded to the nearest integer.
+ *
+ * @func round
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.15.0|v2.15.0}
+ * @category Math
+ * @sig Number -> Number
+ * @param {number} number The number to round
+ * @return {number} The value of the given number rounded to the nearest integer
+ * @example
+ *
+ * RA.round(0.9); //=> 1
+ * RA.round(5.95); //=> 6
+ * RA.round(5.5); //=> 6
+ * RA.round(5.05); //=> 5
+ * RA.round(-5.05); //=> -5
+ * RA.round(-5.5); //=> -5
+ * RA.round(-5.95); //=> -6
+ */
+
+var round = curryN(1, bind(Math.round, Math));
+export default round;

package/es/seq.js

@@ -0,0 +1,44 @@
+import { curry, map, tap } from 'ramda';
+/* eslint-disable max-len */
+
+/**
+ * Runs the given list of functions in order with the supplied object, then returns the object.
+ * Also known as the normal order sequencing combinator.
+ *
+ * Acts as a transducer if a transformer is given as second parameter.
+ *
+ * @func seq
+ * @aliases sequencing
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.3.0|v2.3.0}
+ * @category Function
+ * @sig [(a -> *), (a -> *), ...] -> a -> a
+ * @param {Array} fns The list of functions to call in order with `x` whose return values will be thrown away
+ * @param {*} x
+ * @return {*} `x`
+ * @see {@link http://ramdajs.com/docs/#tap|R.tap}, {@link http://www.cs.rpi.edu/academics/courses/spring11/proglang/handouts/lambda-calculus-chapter.pdf|sequencing combinator explained}
+ * @example
+ *
+ * RA.seq([console.info, console.log])('foo'); //=> prints 'foo' via info then log
+ *
+ * // usage in composition
+ * R.pipe(
+ *   R.concat('prefix '),
+ *   RA.seq([
+ *     console.info, //=> prints 'prefix test'
+ *     console.log //=> prints 'prefix test'
+ *   ]),
+ *   R.toUpper
+ * )('test'); //=> 'PREFIX TEST'
+ */
+
+/* eslint-enable max-len */
+
+var seq = curry(function (fns, x) {
+  return tap(function (tx) {
+    return map(function (fn) {
+      return fn(tx);
+    })(fns);
+  })(x);
+});
+export default seq;

package/es/sign.js

@@ -0,0 +1,27 @@
+import { bind, curryN } from 'ramda';
+import isFunction from './isFunction';
+import ponyfill from './internal/ponyfills/Math.sign';
+export var signPonyfill = curryN(1, ponyfill);
+/**
+ * Returns the sign of a number, indicating whether the number is positive, negative or zero.
+ *
+ * @func sign
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.15.0|v2.15.0}
+ * @category Math
+ * @sig Number | String -> Number
+ * @param {number} number A number
+ * @return {number} A number representing the sign of the given argument. If the argument is a positive number, negative number, positive zero or negative zero, the function will return 1, -1, 0 or -0 respectively. Otherwise, NaN is returned
+ * @example
+ *
+ * RA.sign(3); //  1
+ * RA.sign(-3); // -1
+ * RA.sign('-3'); // -1
+ * RA.sign(0); //  0
+ * RA.sign(-0); // -0
+ * RA.sign(NaN); // NaN
+ * RA.sign('foo'); // NaN
+ */
+
+var sign = isFunction(Math.sign) ? curryN(1, bind(Math.sign, Math)) : signPonyfill;
+export default sign;

package/es/skipTake.js

@@ -0,0 +1,22 @@
+import { curry, addIndex, filter, pipe, modulo, identical, nthArg, __ } from 'ramda';
+/**
+ * When given a number n and an array, returns an array containing every nth element.
+ *
+ * @func skipTake
+ * @memberOf RA
+ * @category List
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.26.0|v2.26.0}
+ * @sig Number -> [a] -> [a]
+ * @param {number} the nth element to extract
+ * @param {Array} value the input array
+ * @return {Array} An array containing every nth element
+ * @example
+ *
+ * RA.skipTake(2, [1,2,3,4]) //=> [1, 3]
+ * RA.skipTake(3, R.range(0, 20)); //=> [0, 3, 6, 9, 12, 15, 18]
+ */
+
+var skipTake = curry(function (n, list) {
+  return addIndex(filter)(pipe(nthArg(1), modulo(__, n), identical(0)))(list);
+});
+export default skipTake;

package/es/sliceFrom.js

@@ -0,0 +1,22 @@
+import { __, slice } from 'ramda';
+/**
+ * Returns the elements of the given list or string (or object with a slice method)
+ * from fromIndex (inclusive).
+ * Dispatches to the slice method of the second argument, if present.
+ *
+ * @func sliceFrom
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.16.0|v1.16.0}
+ * @category List
+ * @sig  Number -> [a] -> [a]
+ * @param {number} fromIndex The start index (inclusive)
+ * @param {Array|string} list The list or string to slice
+ * @return {Array|string} The sliced list or string
+ * @see {@link http://ramdajs.com/docs/#slice|R.slice}, {@link RA.sliceTo|sliceTo}
+ * @example
+ *
+ * RA.sliceFrom(1, [1, 2, 3]); //=> [2, 3]
+ */
+
+var sliceFrom = slice(__, Infinity);
+export default sliceFrom;

package/es/sliceTo.js

@@ -0,0 +1,22 @@
+import { slice } from 'ramda';
+/**
+ * Returns the elements of the given list or string (or object with a slice method)
+ * to toIndex (exclusive).
+ * Dispatches to the slice method of the second argument, if present.
+ *
+ * @func sliceTo
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.16.0|v1.16.0}
+ * @category List
+ * @sig  Number -> [a] -> [a]
+ * @param {number} toIndex The end index (exclusive)
+ * @param {Array|string} list The list or string to slice
+ * @return {Array|string} The sliced list or string
+ * @see {@link http://ramdajs.com/docs/#slice|R.slice}, {@link RA.sliceFrom|sliceFrom}
+ * @example
+ *
+ * RA.sliceTo(2, [1, 2, 3]); //=> [1, 2]
+ */
+
+var sliceTo = slice(0);
+export default sliceTo;

package/es/sortByProps.js

@@ -0,0 +1,52 @@
+function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import { reduce, either, curry, prop, sort, comparator, map, lt } from 'ramda';
+/**
+ * Sort a list of objects by a list of props (if first prop value is equivalent, sort by second, etc).
+ *
+ * @func sortByProps
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.26.0|v2.26.0}
+ * @category List
+ * @sig [k] -> [{k: v}] -> [{k: v}]
+ * @param {Array.<string>} props A list of properties 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 properties in the props param
+ * @example
+ *
+ * sortByProps(['num'], [{num: 3}, {num: 2}, {num: 1}])
+ * //=> [{num: 1}, {num: 2} {num: 3}]
+ * sortByProps(['letter', 'num'], [{num: 3, letter: 'a'}, {num: 2, letter: 'a'} {num: 1, letter: 'z'}])
+ * //=> [ {num: 2, letter: 'a'}, {num: 3, letter: 'a'}, {num: 1, letter: 'z'}]
+ * sortByProps(['name', 'num'], [{num: 3}, {num: 2}, {num: 1}])
+ * //=> [{num: 1}, {num: 2}, {num: 3}]
+ */
+
+var sortByProps = curry(function (props, list) {
+  var firstTruthy = function firstTruthy(_ref) {
+    var _ref2 = _toArray(_ref),
+        head = _ref2[0],
+        tail = _ref2.slice(1);
+
+    return reduce(either, head, tail);
+  };
+
+  var makeComparator = function makeComparator(propName) {
+    return comparator(function (a, b) {
+      return lt(prop(propName, a), prop(propName, b));
+    });
+  };
+
+  return sort(firstTruthy(map(makeComparator, props)), list);
+});
+export default sortByProps;