rambda 7.0.2 → 7.1.1

package/dist/rambda.js

@@ -15,14 +15,12 @@ function add(a, b) {
   return Number(a) + Number(b);
 }
 
+const cloneList = list => Array.prototype.slice.call(list);
+
 function curry(fn, args = []) {
   return (..._args) => (rest => rest.length >= fn.length ? fn(...rest) : curry(fn, rest))([...args, ..._args]);
 }
 
-const cloneList = list => {
-  return Array.prototype.slice.call(list);
-};
-
 function adjustFn(index, replaceFn, list) {
   const actualIndex = index < 0 ? list.length + index : index;
   if (index >= list.length || actualIndex < 0) return list;
@@ -60,7 +58,7 @@ function allPass(predicates) {
 }
 
 function always(x) {
-  return () => x;
+  return _ => x;
 }
 
 function and(a, b) {
@@ -261,11 +259,11 @@ function _curryN(n, cache, fn) {
     }
 
     const remaining = n - args.length;
-    return args.length >= n ? fn.apply(this, args) : _arity(remaining, _curryN(n, args, fn));
+    return args.length >= n ? fn.apply(this, args) : _arity$1(remaining, _curryN(n, args, fn));
   };
 }
 
-function _arity(n, fn) {
+function _arity$1(n, fn) {
   switch (n) {
     case 0:
       return function () {
@@ -331,7 +329,7 @@ function curryN(n, fn) {
     throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
   }
 
-  return _arity(n, _curryN(n, [], fn));
+  return _arity$1(n, _curryN(n, [], fn));
 }
 
 function bind(fn, thisObj) {
@@ -383,26 +381,106 @@ function complement(fn) {
   return (...input) => !fn(...input);
 }
 
-function compose(...fns) {
-  if (fns.length === 0) {
-    throw new Error('compose requires at least one argument');
+const _keys = Object.keys;
+
+function reduceFn(reducer, acc, list) {
+  if (!_isArray(list)) {
+    throw new TypeError('reduce: list must be array or iterable');
   }
 
-  return function (...args) {
-    const list = fns.slice();
+  let index = 0;
+  const len = list.length;
 
-    if (list.length > 0) {
-      const fn = list.pop();
-      let result = fn.apply(this, args);
+  while (index < len) {
+    acc = reducer(acc, list[index], index, list);
+    index++;
+  }
 
-      while (list.length > 0) {
-        result = list.pop()(result);
-      }
+  return acc;
+}
+const reduce = curry(reduceFn);
 
-      return result;
-    }
+function _arity(n, fn) {
+  switch (n) {
+    case 0:
+      return function () {
+        return fn.apply(this, arguments);
+      };
+
+    case 1:
+      return function (a0) {
+        return fn.apply(this, arguments);
+      };
+
+    case 2:
+      return function (a0, a1) {
+        return fn.apply(this, arguments);
+      };
+
+    case 3:
+      return function (a0, a1, a2) {
+        return fn.apply(this, arguments);
+      };
+
+    case 4:
+      return function (a0, a1, a2, a3) {
+        return fn.apply(this, arguments);
+      };
+
+    case 5:
+      return function (a0, a1, a2, a3, a4) {
+        return fn.apply(this, arguments);
+      };
+
+    case 6:
+      return function (a0, a1, a2, a3, a4, a5) {
+        return fn.apply(this, arguments);
+      };
+
+    case 7:
+      return function (a0, a1, a2, a3, a4, a5, a6) {
+        return fn.apply(this, arguments);
+      };
+
+    case 8:
+      return function (a0, a1, a2, a3, a4, a5, a6, a7) {
+        return fn.apply(this, arguments);
+      };
+
+    case 9:
+      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {
+        return fn.apply(this, arguments);
+      };
+
+    case 10:
+      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+        return fn.apply(this, arguments);
+      };
+
+    default:
+      throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
+  }
+}
+function _pipe(f, g) {
+  return function () {
+    return g.call(this, f.apply(this, arguments));
   };
 }
+function pipe() {
+  if (arguments.length === 0) {
+    throw new Error('pipe requires at least one argument');
+  }
+
+  return _arity(arguments[0].length, reduceFn(_pipe, arguments[0], Array.prototype.slice.call(arguments, 1, Infinity)));
+}
+
+function compose() {
+  if (arguments.length === 0) {
+    throw new Error('compose requires at least one argument');
+  }
+
+  return pipe.apply(this, Array.prototype.slice.call(arguments, 0).reverse());
+}
 
 function concat(x, y) {
   if (arguments.length === 1) return _y => concat(x, _y);
@@ -423,8 +501,6 @@ function cond(conditions) {
   };
 }
 
-const _keys = Object.keys;
-
 function mapArray(fn, list, isIndexed = false) {
   let index = 0;
   const willReturn = Array(list.length);
@@ -469,30 +545,39 @@ function max(x, y) {
   return y > x ? y : x;
 }
 
-function reduceFn(reducer, acc, list) {
-  if (!_isArray(list)) {
-    throw new TypeError('reduce: list must be array or iterable');
-  }
-
-  let index = 0;
-  const len = list.length;
+function converge(fn, transformers) {
+  if (arguments.length === 1) return _transformers => converge(fn, _transformers);
+  const highestArity = reduce((a, b) => max(a, b.length), 0, transformers);
+  return curryN(highestArity, function () {
+    return fn.apply(this, map(g => g.apply(this, arguments), transformers));
+  });
+}
 
-  while (index < len) {
-    acc = reducer(acc, list[index], index, list);
-    index++;
+function count(predicate, list) {
+  if (arguments.length === 1) {
+    return _list => count(predicate, _list);
   }
 
-  return acc;
+  if (!_isArray(list)) return 0;
+  return list.filter(x => predicate(x)).length;
 }
 
-const reduce = curry(reduceFn);
+function countBy(fn, list) {
+  if (arguments.length === 1) {
+    return _list => countBy(fn, _list);
+  }
 
-function converge(fn, transformers) {
-  if (arguments.length === 1) return _transformers => converge(fn, _transformers);
-  const highestArity = reduce((a, b) => max(a, b.length), 0, transformers);
-  return curryN(highestArity, function () {
-    return fn.apply(this, map(g => g.apply(this, arguments), transformers));
+  const willReturn = {};
+  list.forEach(item => {
+    const key = fn(item);
+
+    if (!willReturn[key]) {
+      willReturn[key] = 1;
+    } else {
+      willReturn[key]++;
+    }
   });
+  return willReturn;
 }
 
 const dec = x => x - 1;
@@ -519,7 +604,7 @@ function type(input) {
   }
 
   const typeResult = Object.prototype.toString.call(input).slice(8, -1);
-  return typeResult === 'AsyncFunction' ? 'Async' : typeResult;
+  return typeResult === 'AsyncFunction' ? 'Promise' : typeResult;
 }
 
 function _lastIndexOf(valueToFind, list) {
@@ -1113,7 +1198,7 @@ function flipFn(fn) {
       return fn(input[1], input[0], input[2], input[3]);
     }
 
-    throw new Error("R.flip doesn't work with arity > 4");
+    throw new Error('R.flip doesn\'t work with arity > 4');
   };
 }
 
@@ -1216,6 +1301,10 @@ function has(prop, obj) {
   return obj.hasOwnProperty(prop);
 }
 
+function createPath(path, delimiter = '.') {
+  return typeof path === 'string' ? path.split(delimiter) : path;
+}
+
 function path(pathInput, obj) {
   if (arguments.length === 1) return _obj => path(pathInput, _obj);
 
@@ -1225,7 +1314,7 @@ function path(pathInput, obj) {
 
   let willReturn = obj;
   let counter = 0;
-  const pathArrValue = typeof pathInput === 'string' ? pathInput.split('.') : pathInput;
+  const pathArrValue = createPath(pathInput);
 
   while (counter < pathArrValue.length) {
     if (willReturn === null || willReturn === undefined) {
@@ -1404,6 +1493,10 @@ function join(glue, list) {
   return list.join(glue);
 }
 
+function juxt(listOfFunctions) {
+  return (...args) => listOfFunctions.map(fn => fn(...args));
+}
+
 function keys(x) {
   return Object.keys(x);
 }
@@ -1438,10 +1531,10 @@ function lens(getter, setter) {
   };
 }
 
-function nth(index, list) {
-  if (arguments.length === 1) return _list => nth(index, _list);
-  const idx = index < 0 ? list.length + index : index;
-  return Object.prototype.toString.call(list) === '[object String]' ? list.charAt(idx) : list[idx];
+function nth(index, input) {
+  if (arguments.length === 1) return _input => nth(index, _input);
+  const idx = index < 0 ? input.length + index : index;
+  return Object.prototype.toString.call(input) === '[object String]' ? input.charAt(idx) : input[idx];
 }
 
 function updateFn(index, newValue, list) {
@@ -1500,15 +1593,15 @@ function median(list) {
   }).slice(idx, idx + width));
 }
 
-function merge(target, newProps) {
-  if (arguments.length === 1) return _newProps => merge(target, _newProps);
+function mergeRight(target, newProps) {
+  if (arguments.length === 1) return _newProps => mergeRight(target, _newProps);
   return Object.assign({}, target || {}, newProps || {});
 }
 
 function mergeAll(arr) {
   let willReturn = {};
   map(val => {
-    willReturn = merge(willReturn, val);
+    willReturn = mergeRight(willReturn, val);
   }, arr);
   return willReturn;
 }
@@ -1535,9 +1628,32 @@ function mergeDeepRight(target, source) {
 
 function mergeLeft(x, y) {
   if (arguments.length === 1) return _y => mergeLeft(x, _y);
-  return merge(y, x);
+  return mergeRight(y, x);
 }
 
+function mergeWithFn(mergeFn, a, b) {
+  const willReturn = {};
+  Object.keys(a).forEach(key => {
+    if (b[key] === undefined) {
+      willReturn[key] = a[key];
+    } else {
+      willReturn[key] = mergeFn(a[key], b[key]);
+    }
+  });
+  Object.keys(b).forEach(key => {
+    if (willReturn[key] !== undefined) return;
+
+    if (a[key] === undefined) {
+      willReturn[key] = b[key];
+    } else {
+      willReturn[key] = mergeFn(a[key], b[key]);
+    }
+  });
+  return willReturn;
+}
+
+const mergeWith = curry(mergeWithFn);
+
 function min(x, y) {
   if (arguments.length === 1) return _y => min(x, _y);
   return y < x ? y : x;
@@ -1580,10 +1696,10 @@ function none(predicate, list) {
   if (arguments.length === 1) return _list => none(predicate, _list);
 
   for (let i = 0; i < list.length; i++) {
-    if (!predicate(list[i])) return true;
+    if (predicate(list[i])) return false;
   }
 
-  return false;
+  return true;
 }
 
 function not(input) {
@@ -1611,7 +1727,7 @@ function omit(propsToOmit, obj) {
     return undefined;
   }
 
-  const propsToOmitValue = typeof propsToOmit === 'string' ? propsToOmit.split(',') : propsToOmit;
+  const propsToOmitValue = createPath(propsToOmit, ',');
   const willReturn = {};
 
   for (const key in obj) {
@@ -1623,6 +1739,18 @@ function omit(propsToOmit, obj) {
   return willReturn;
 }
 
+function on(binaryFn, unaryFn, a, b) {
+  if (arguments.length === 3) {
+    return _b => on(binaryFn, unaryFn, a, _b);
+  }
+
+  if (arguments.length === 2) {
+    return (_a, _b) => on(binaryFn, unaryFn, _a, _b);
+  }
+
+  return binaryFn(unaryFn(a), unaryFn(b));
+}
+
 function onceFn(fn, context) {
   let result;
   return function () {
@@ -1671,6 +1799,18 @@ function partial(fn, ...args) {
   };
 }
 
+function partialObject(fn, input) {
+  return rest => {
+    if (type(fn) === 'Async') {
+      return new Promise((resolve, reject) => {
+        fn(mergeDeepRight(rest, input)).then(resolve).catch(reject);
+      });
+    }
+
+    return fn(mergeDeepRight(rest, input));
+  };
+}
+
 function partitionObject(predicate, iterable) {
   const yes = {};
   const no = {};
@@ -1734,7 +1874,7 @@ function pick(propsToPick, input) {
     return undefined;
   }
 
-  const keys = typeof propsToPick === 'string' ? propsToPick.split(',') : propsToPick;
+  const keys = createPath(propsToPick, ',');
   const willReturn = {};
   let counter = 0;
 
@@ -1756,7 +1896,7 @@ function pickAll(propsToPick, obj) {
     return undefined;
   }
 
-  const keysValue = typeof propsToPick === 'string' ? propsToPick.split(',') : propsToPick;
+  const keysValue = createPath(propsToPick, ',');
   const willReturn = {};
   let counter = 0;
 
@@ -1773,24 +1913,6 @@ function pickAll(propsToPick, obj) {
   return willReturn;
 }
 
-function pipe(...fns) {
-  if (fns.length === 0) throw new Error('pipe requires at least one argument');
-  return (...args) => {
-    const list = fns.slice();
-
-    if (list.length > 0) {
-      const fn = list.shift();
-      let result = fn(...args);
-
-      while (list.length > 0) {
-        result = list.shift()(result);
-      }
-
-      return result;
-    }
-  };
-}
-
 function pluck(property, list) {
   if (arguments.length === 1) return _list => pluck(property, _list);
   const willReturn = [];
@@ -1830,6 +1952,12 @@ function propOrFn(defaultValue, property, obj) {
 
 const propOr = curry(propOrFn);
 
+function propSatisfiesFn(predicate, property, obj) {
+  return predicate(prop(property, obj));
+}
+
+const propSatisfies = curry(propSatisfiesFn);
+
 function props(propsToPick, obj) {
   if (arguments.length === 1) {
     return _obj => props(propsToPick, _obj);
@@ -2135,9 +2263,7 @@ function trim(str) {
   return str.trim();
 }
 
-function isFunction(fn) {
-  return ['Async', 'Function'].includes(type(fn));
-}
+const isFunction = x => ['Promise', 'Function'].includes(type(x));
 
 function tryCatch(fn, fallback) {
   if (!isFunction(fn)) {
@@ -2208,6 +2334,58 @@ function unless(predicate, whenFalse) {
   return input => predicate(input) ? input : whenFalse(input);
 }
 
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+
+  return target;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function unwind(property, obj) {
+  if (arguments.length === 1) {
+    return _obj => unwind(property, _obj);
+  }
+
+  if (!_isArray(obj[property])) return [obj];
+  return mapArray(x => _objectSpread2(_objectSpread2({}, obj), {}, {
+    [property]: x
+  }), obj[property]);
+}
+
 function values(obj) {
   if (type(obj) !== 'Object') return [];
   return Object.values(obj);
@@ -2248,6 +2426,20 @@ function where(conditions, input) {
   return flag;
 }
 
+function whereAny(conditions, input) {
+  if (input === undefined) {
+    return _input => whereAny(conditions, _input);
+  }
+
+  for (const prop in conditions) {
+    if (conditions[prop](input[prop])) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 function whereEq(condition, input) {
   if (arguments.length === 1) {
     return _input => whereEq(condition, _input);
@@ -2298,8 +2490,11 @@ const zipWith = curry(zipWithFn);
 
 exports.F = F;
 exports.T = T;
+exports.__findHighestArity = __findHighestArity;
+exports._arity = _arity;
 exports._indexOf = _indexOf;
 exports._lastIndexOf = _lastIndexOf;
+exports._pipe = _pipe;
 exports.add = add;
 exports.adjust = adjust;
 exports.all = all;
@@ -2323,6 +2518,8 @@ exports.compose = compose;
 exports.concat = concat;
 exports.cond = cond;
 exports.converge = converge;
+exports.count = count;
+exports.countBy = countBy;
 exports.curry = curry;
 exports.curryN = curryN;
 exports.dec = dec;
@@ -2373,6 +2570,7 @@ exports.is = is;
 exports.isEmpty = isEmpty;
 exports.isNil = isNil;
 exports.join = join;
+exports.juxt = juxt;
 exports.keys = keys;
 exports.last = last;
 exports.lastIndexOf = lastIndexOf;
@@ -2392,10 +2590,12 @@ exports.maxBy = maxBy;
 exports.maxByFn = maxByFn;
 exports.mean = mean;
 exports.median = median;
-exports.merge = merge;
+exports.merge = mergeRight;
 exports.mergeAll = mergeAll;
 exports.mergeDeepRight = mergeDeepRight;
 exports.mergeLeft = mergeLeft;
+exports.mergeRight = mergeRight;
+exports.mergeWith = mergeWith;
 exports.min = min;
 exports.minBy = minBy;
 exports.minByFn = minByFn;
@@ -2409,10 +2609,12 @@ exports.nth = nth;
 exports.objOf = objOf;
 exports.of = of;
 exports.omit = omit;
+exports.on = on;
 exports.once = once;
 exports.or = or;
 exports.over = over;
 exports.partial = partial;
+exports.partialObject = partialObject;
 exports.partition = partition;
 exports.partitionArray = partitionArray;
 exports.partitionObject = partitionObject;
@@ -2430,9 +2632,11 @@ exports.prop = prop;
 exports.propEq = propEq;
 exports.propIs = propIs;
 exports.propOr = propOr;
+exports.propSatisfies = propSatisfies;
 exports.props = props;
 exports.range = range;
 exports.reduce = reduce;
+exports.reduceFn = reduceFn;
 exports.reject = reject;
 exports.repeat = repeat;
 exports.replace = replace;
@@ -2470,11 +2674,13 @@ exports.union = union;
 exports.uniq = uniq;
 exports.uniqWith = uniqWith;
 exports.unless = unless;
+exports.unwind = unwind;
 exports.update = update;
 exports.values = values;
 exports.view = view;
 exports.when = when;
 exports.where = where;
+exports.whereAny = whereAny;
 exports.whereEq = whereEq;
 exports.without = without;
 exports.xor = xor;