ramda-adjunct 2.34.0

package/lib/toArray.js

@@ -0,0 +1,40 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.fromPonyfill = void 0;
+
+var _ramda = require("ramda");
+
+var _isIterable = _interopRequireDefault(require("./isIterable"));
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+var _Array = _interopRequireDefault(require("./internal/ponyfills/Array.from"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var fromPonyfill = (0, _ramda.curryN)(1, _Array["default"]);
+exports.fromPonyfill = fromPonyfill;
+var fromArray = (0, _isFunction["default"])(Array.from) ? (0, _ramda.curryN)(1, Array.from) : fromPonyfill;
+/**
+ * Converts value to an array.
+ *
+ * @func toArray
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category List
+ * @sig * -> [a]
+ * @param {*} val The value to convert
+ * @return {Array}
+ * @example
+ *
+ * RA.toArray([1, 2]); //=> [1, 2]
+ * RA.toArray({'foo': 1, 'bar': 2}); //=> [1, 2]
+ * RA.toArray('abc'); //=> ['a', 'b', 'c']
+ * RA.toArray(1); //=> []
+ * RA.toArray(null); //=> []
+ */
+
+var toArray = (0, _ramda.ifElse)(_isIterable["default"], fromArray, _ramda.values);
+var _default = toArray;
+exports["default"] = _default;

package/lib/toInteger32.js

@@ -0,0 +1,30 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Converts double-precision 64-bit binary format IEEE 754 to signed 32 bit integer number.
+ *
+ * @func toInteger32
+ * @aliases toInt32
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.28.0|v2.28.0}
+ * @category Math
+ * @sig Number -> Number
+ * @param {number} number A number
+ * @return {number} A signed 32-bit integer number
+ * @see {@link RA.toUInteger32|toUInteger32}, {@link http://speakingjs.com/es5/ch11.html#integers_via_bitwise_operators}
+ * @example
+ *
+ * RA.toInteger32(2 ** 35); // => 0
+ * RA.toInteger32(2 ** 30); // => 1073741824
+ */
+// eslint-disable-next-line no-bitwise
+var toInteger32 = (0, _ramda.curryN)(1, function (val) {
+  return val >> 0;
+});
+var _default = toInteger32;
+exports["default"] = _default;

package/lib/toUinteger32.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Converts double-precision 64-bit binary format IEEE 754 to unsigned 32 bit integer number.
+ *
+ * @func toUinteger32
+ * @aliases toUint32
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.28.0|v2.28.0}
+ * @category Math
+ * @sig Number -> Number
+ * @param {number} val Value to be converted.
+ * @return {number}
+ * @see {@link RA.toInteger32|toInteger32}, {@link http://speakingjs.com/es5/ch11.html#integers_via_bitwise_operators}
+ * @example
+ *
+ * RA.toUinteger32(1.5); //=> 1
+ * RA.toInteger32(2 ** 35); // => 0
+ * RA.toInteger32(2 ** 31); // => 2147483648
+ * RA.toInteger32(2 ** 30); // => 1073741824
+ */
+// eslint-disable-next-line no-bitwise
+var toUinteger32 = (0, _ramda.curryN)(1, function (val) {
+  return val >>> 0;
+});
+var _default = toUinteger32;
+exports["default"] = _default;

package/lib/trimCharsEnd.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _contained = _interopRequireDefault(require("./contained"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Removes specified characters from the end of a string.
+ *
+ * @func trimCharsEnd
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.25.0|v2.25.0}
+ * @category String
+ * @sig String -> String
+ * @param {string} chars The characters to trim
+ * @param {string} value The string to trim
+ * @return {string} Returns the trimmed string.
+ * @example
+ *
+ * RA.trimCharsEnd('_-', '-_-abc-_-'); //=> '-_-abc'
+ */
+var trimCharsEnd = (0, _ramda.curry)(function (chars, value) {
+  return (0, _ramda.pipe)((0, _ramda.split)(''), (0, _ramda.dropLastWhile)((0, _contained["default"])(chars)), (0, _ramda.join)(''))(value);
+});
+var _default = trimCharsEnd;
+exports["default"] = _default;

package/lib/trimCharsStart.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _contained = _interopRequireDefault(require("./contained"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Removes specified characters from the beginning of a string.
+ *
+ * @func trimCharsStart
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.24.0|v2.24.0}
+ * @category String
+ * @sig String -> String
+ * @param {string} chars The characters to trim
+ * @param {string} value The string to trim
+ * @return {string} Returns the trimmed string.
+ * @example
+ *
+ * RA.trimCharsStart('_-', '-_-abc-_-'); //=> 'abc-_-'
+ */
+var trimCharsStart = (0, _ramda.curry)(function (chars, value) {
+  return (0, _ramda.pipe)((0, _ramda.split)(''), (0, _ramda.dropWhile)((0, _contained["default"])(chars)), (0, _ramda.join)(''))(value);
+});
+var _default = trimCharsStart;
+exports["default"] = _default;

package/lib/trimEnd.js

@@ -0,0 +1,36 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.trimEndInvoker = exports.trimEndPonyfill = void 0;
+
+var _ramda = require("ramda");
+
+var _String = _interopRequireDefault(require("./internal/ponyfills/String.trimEnd"));
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var trimEndPonyfill = _String["default"];
+exports.trimEndPonyfill = trimEndPonyfill;
+var trimEndInvoker = (0, _ramda.invoker)(0, 'trimEnd');
+/**
+ * Removes whitespace from the end of a string.
+ *
+ * @func trimEnd
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category String
+ * @sig String -> String
+ * @param {string} value String value to have the whitespace removed from the end
+ * @return {string} A new string representing the calling string stripped of whitespace from its end (right end).
+ * @see {@link RA.trimEnd|trimEnd}
+ * @example
+ *
+ * RA.trimEnd('abc   '); //=> 'abc'
+ */
+
+exports.trimEndInvoker = trimEndInvoker;
+var trimEnd = (0, _isFunction["default"])(String.prototype.trimEnd) ? trimEndInvoker : trimEndPonyfill;
+var _default = trimEnd;
+exports["default"] = _default;

package/lib/trimStart.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.trimStartInvoker = exports.trimStartPonyfill = void 0;
+
+var _ramda = require("ramda");
+
+var _String = _interopRequireDefault(require("./internal/ponyfills/String.trimStart"));
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var trimStartPonyfill = _String["default"];
+exports.trimStartPonyfill = trimStartPonyfill;
+var trimStartInvoker = (0, _ramda.invoker)(0, 'trimStart');
+/**
+ * Removes whitespace from the beginning of a string.
+ *
+ * @func trimStart
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category String
+ * @sig String -> String
+ * @param {string} value String value to have the whitespace removed from the beginning
+ * @return {string} A new string representing the calling string stripped of whitespace from its beginning (left end).
+ * @example
+ *
+ * RA.trimStart('  abc'); //=> 'abc'
+ */
+
+exports.trimStartInvoker = trimStartInvoker;
+var trimStart = (0, _isFunction["default"])(String.prototype.trimStart) ? trimStartInvoker : trimStartPonyfill;
+var _default = trimStart;
+exports["default"] = _default;

package/lib/trunc.js

@@ -0,0 +1,39 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.truncPonyfill = void 0;
+
+var _ramda = require("ramda");
+
+var _Math = _interopRequireDefault(require("./internal/ponyfills/Math.trunc"));
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var truncPonyfill = (0, _ramda.curryN)(1, _Math["default"]);
+/**
+ * Returns the integer part of a number by removing any fractional digits.
+ *
+ * @func trunc
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.15.0|v2.15.0}
+ * @category Math
+ * @sig Number | String -> Number
+ * @param {number|string} number The number to trunc
+ * @return {number} The integer part of the given number
+ * @example
+ *
+ * RA.trunc(13.37); //=> 13
+ * RA.trunc(42.84); //=> 42
+ * RA.trunc(0.123); //=>  0
+ * RA.trunc(-0.123); //=> -0
+ * RA.trunc('-1.123'); //=> -1
+ * RA.trunc(NaN); //=> NaN
+ * RA.trunc('foo'); //=> NaN
+ */
+
+exports.truncPonyfill = truncPonyfill;
+var trunc = (0, _isFunction["default"])(Math.trunc) ? (0, _ramda.curryN)(1, (0, _ramda.bind)(Math.trunc, Math)) : truncPonyfill;
+var _default = trunc;
+exports["default"] = _default;

package/lib/unzipObjWith.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _lengthEq = _interopRequireDefault(require("./lengthEq"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Creates a new list out of the supplied object by applying the function to each key/value pairing.
+ *
+ * @func unzipObjWith
+ * @memberOf RA
+ * @category Object
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @sig  (v, k) => [k, v] -> { k: v } -> [[k], [v]]
+ * @param {Function} fn The function to transform each value-key pair
+ * @param {Object} obj Object to unzip
+ * @return {Array} A pair of tw lists: a list of keys and a list of values
+ * @see {@link https://ramdajs.com/docs/#zipObj|zipObj}, {@link RA.zipObjWith|zipObjWith}
+ * @example
+ *
+ * RA.unzipObjWith((v, k) => [`new${k.toUpperCase()}`, 2 * v], { a: 1, b: 2, c: 3 });
+ * //=> [['newA', 'newB', 'newC'], [2, 4, 6]]
+ */
+var unzipObjWith = (0, _ramda.curryN)(2, function (fn, obj) {
+  return (0, _ramda.pipe)(_ramda.toPairs, (0, _ramda.map)((0, _ramda.pipe)(_ramda.flip, _ramda.apply)(fn)), _ramda.transpose, (0, _ramda.when)((0, _lengthEq["default"])(0), function () {
+    return [[], []];
+  }))(obj);
+});
+var _default = unzipObjWith;
+exports["default"] = _default;

package/lib/viewOr.js

@@ -0,0 +1,36 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns a "view" of the given data structure, determined by the given lens.
+ * The lens's focus determines which portion of the data structure is visible.
+ * Returns the defaultValue if "view" is null, undefined or NaN; otherwise the "view" is returned.
+ *
+ * @func viewOr
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|1.13.0}
+ * @category Object
+ * @typedef Lens s b = Functor f => (b -> f b) -> s -> f s
+ * @sig a -> Lens s b -> s -> b | a
+ * @see {@link http://ramdajs.com/docs/#view|R.view}
+ * @param {*} defaultValue The default value
+ * @param {Function} lens Van Laarhoven lens
+ * @param {*} data The data structure
+ * @returns {*} "view" or defaultValue
+ *
+ * @example
+ *
+ * RA.viewOr('N/A', R.lensProp('x'), {}); // => 'N/A'
+ * RA.viewOr('N/A', R.lensProp('x'), { x: 1 }); // => 1
+ * RA.viewOr('some', R.lensProp('y'), { y: null }); // => 'some'
+ * RA.viewOr('some', R.lensProp('y'), { y: false }); // => false
+ */
+var viewOr = (0, _ramda.curryN)(3, function (defaultValue, lens, data) {
+  return (0, _ramda.defaultTo)(defaultValue, (0, _ramda.view)(lens, data));
+});
+var _default = viewOr;
+exports["default"] = _default;

package/lib/weave.js

@@ -0,0 +1,42 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Weaves a configuration into function returning the runnable monad like `Reader` or `Free`.
+ * This allows us to pre-bind the configuration in advance and use the weaved function
+ * without need to explicitly pass the configuration on every call.
+ *
+ * @func weave
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.7.0|v1.7.0}
+ * @category Function
+ * @sig (*... -> *) -> * -> (*... -> *)
+ * @param {Function} fn The function to weave
+ * @param {*} config The configuration to weave into fn
+ * @return {Function} Auto-curried weaved function
+ * @example
+ *
+ * const { Reader: reader } = require('monet');
+ *
+ * const log = value => reader(
+ *   config => config.log(value)
+ * );
+ *
+ * // no weaving
+ * log('test').run(console); //=> prints 'test'
+ *
+ * // weaving
+ * const wlog = RA.weave(log, console);
+ * wlog('test'); //=> prints 'test'
+ */
+var weave = (0, _ramda.curryN)(2, function (fn, config) {
+  return (0, _ramda.curryN)(fn.length, function () {
+    return fn.apply(void 0, arguments).run(config);
+  });
+});
+var _default = weave;
+exports["default"] = _default;

package/lib/weaveLazy.js

@@ -0,0 +1,44 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Weaves a configuration into function returning the runnable monad like `Reader` or `Free`.
+ * This allows us to pre-bind the configuration in advance and use the weaved function
+ * without need to explicitly pass the configuration on every call.
+ *
+ * @func weaveLazy
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.10.0|v1.10.0}
+ * @category Function
+ * @sig (*... -> *) -> (* -> *) -> (*... -> *)
+ * @param {Function} fn The function to weave
+ * @param {Function} configAccessor The function that returns the configuration object
+ * @return {Function} Auto-curried weaved function
+ * @example
+ *
+ * const { Reader: reader } = require('monet');
+ *
+ * const log = value => reader(
+ *   config => config.log(value)
+ * );
+ *
+ * const consoleAccessor = R.always(console);
+ *
+ * // no weaving
+ * log('test').run(console); //=> prints 'test'
+ *
+ * // weaving
+ * const wlog = RA.weaveLazy(log, consoleAccessor);
+ * wlog('test'); //=> prints 'test'
+ */
+var weaveLazy = (0, _ramda.curryN)(2, function (fn, configAccessor) {
+  return (0, _ramda.curryN)(fn.length, function () {
+    return fn.apply(void 0, arguments).run(configAccessor());
+  });
+});
+var _default = weaveLazy;
+exports["default"] = _default;

package/lib/zipObjWith.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Creates a new object out of a list of keys and a list of values by applying the function
+ * to each equally-positioned pair in the lists.
+ * Key/value pairing is truncated to the length of the shorter of the two lists.
+ *
+ * @func zipObjWith
+ * @memberOf RA
+ * @category Object
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @sig (b, a) -> [k, v] -> [a] -> [b] -> { k: v }
+ * @param {Function} fn The function to transform each value-key pair
+ * @param {Array} keys Array to transform into the properties on the output object
+ * @param {Array} values Array to transform into the values on the output object
+ * @return {Object}  The object made by pairing up and transforming same-indexed elements of `keys` and `values`.
+ * @see {@link https://ramdajs.com/docs/#zipObj|zipObj}, {@link RA.unzipObjWith|unzipObjWith}
+ * @example
+ *
+ * RA.zipObjWith((value, key) => [key, `${key}${value + 1}`]), ['a', 'b', 'c'], [1, 2, 3]);
+ *  // => { a: 'a2', b: 'b3', c: 'c4' }
+ */
+var zipObjWith = (0, _ramda.curryN)(3, function (fn, keys, values) {
+  return (0, _ramda.pipe)(_ramda.zip, (0, _ramda.map)((0, _ramda.apply)(fn)), _ramda.fromPairs)(values, keys);
+});
+var _default = zipObjWith;
+exports["default"] = _default;